fast-agent-mcp 0.2.58__py3-none-any.whl → 0.3.0__py3-none-any.whl

{mcp_agent → fast_agent/core}/logging/listeners.py

@@ -6,10 +6,88 @@ import asyncio
 import logging
 import time
 from abc import ABC, abstractmethod
-from typing import Dict, List
-
-from mcp_agent.event_progress import convert_log_event
-from mcp_agent.logging.events import Event, EventFilter, EventType
+from typing import TYPE_CHECKING, Dict, List
+
+if TYPE_CHECKING:
+    from fast_agent.event_progress import ProgressEvent
+
+from fast_agent.core.logging.events import Event, EventFilter, EventType
+
+
+def convert_log_event(event: Event) -> "ProgressEvent | None":
+    """Convert a log event to a progress event if applicable."""
+
+    # Import at runtime to avoid circular imports
+    from fast_agent.event_progress import ProgressAction, ProgressEvent
+
+    # Check to see if there is any additional data
+    if not event.data:
+        return None
+
+    event_data = event.data.get("data")
+    if not isinstance(event_data, dict):
+        return None
+
+    progress_action = event_data.get("progress_action")
+    if not progress_action:
+        return None
+
+    # Build target string based on the event type.
+    # Progress display is currently [time] [event] --- [target] [details]
+    namespace = event.namespace
+    agent_name = event_data.get("agent_name")
+    target = agent_name
+    details = ""
+    if progress_action == ProgressAction.FATAL_ERROR:
+        details = event_data.get("error_message", "An error occurred")
+    elif "mcp_aggregator" in namespace:
+        server_name = event_data.get("server_name", "")
+        tool_name = event_data.get("tool_name")
+        if tool_name:
+            # fetch(fetch)
+            details = f"{server_name} ({tool_name})"
+        else:
+            details = f"{server_name}"
+
+        # For TOOL_PROGRESS, use progress message if available, otherwise keep default
+        if progress_action == ProgressAction.TOOL_PROGRESS:
+            progress_message = event_data.get("details", "")
+            if progress_message:  # Only override if message is non-empty
+                details = progress_message
+
+    elif "augmented_llm" in namespace:
+        model = event_data.get("model", "")
+
+        # For all augmented_llm events, put model info in details column
+        details = f"{model}"
+        chat_turn = event_data.get("chat_turn")
+        if chat_turn is not None:
+            details = f"{model} turn {chat_turn}"
+    else:
+        if not target:
+            target = event_data.get("target", "unknown")
+
+    # Extract streaming token count for STREAMING actions
+    streaming_tokens = None
+    if progress_action == ProgressAction.STREAMING:
+        streaming_tokens = event_data.get("details", "")
+
+    # Extract progress data for TOOL_PROGRESS actions
+    progress = None
+    total = None
+    if progress_action == ProgressAction.TOOL_PROGRESS:
+        progress = event_data.get("progress")
+        total = event_data.get("total")
+
+    return ProgressEvent(
+        action=ProgressAction(progress_action),
+        target=target or "unknown",
+        details=details,
+        agent_name=event_data.get("agent_name"),
+        streaming_tokens=streaming_tokens,
+        progress=progress,
+        total=total,
+    )
 
 
 class EventListener(ABC):
@@ -71,10 +149,10 @@ class LoggingListener(FilteredListener):
         """
         Initialize the listener.
         Args:
-            logger: Logger to use for event processing. Defaults to 'mcp_agent'.
+            logger: Logger to use for event processing. Defaults to 'fast_agent'.
         """
         super().__init__(event_filter=event_filter)
-        self.logger = logger or logging.getLogger("mcp_agent")
+        self.logger = logger or logging.getLogger("fast_agent")
 
     async def handle_matched_event(self, event) -> None:
         level_map: Dict[EventType, int] = {
@@ -117,7 +195,7 @@ class ProgressListener(LifecycleAwareListener):
         Args:
             display: Optional display handler. If None, the shared progress_display will be used.
         """
-        from mcp_agent.progress_display import progress_display
+        from fast_agent.ui.progress_display import progress_display
 
         self.display = display or progress_display
 

{mcp_agent → fast_agent/core}/logging/logger.py

@@ -14,13 +14,13 @@ import time
 from contextlib import asynccontextmanager, contextmanager
 from typing import Any, Dict
 
-from mcp_agent.logging.events import Event, EventContext, EventFilter, EventType
-from mcp_agent.logging.listeners import (
+from fast_agent.core.logging.events import Event, EventContext, EventFilter, EventType
+from fast_agent.core.logging.listeners import (
     BatchingListener,
     LoggingListener,
     ProgressListener,
 )
-from mcp_agent.logging.transport import AsyncEventBus, EventTransport
+from fast_agent.core.logging.transport import AsyncEventBus, EventTransport
 
 
 class Logger:
@@ -208,10 +208,10 @@ class LoggingConfig:
             return
 
         # Suppress boto3/botocore logging to prevent flooding
-        logging.getLogger('boto3').setLevel(logging.WARNING)
-        logging.getLogger('botocore').setLevel(logging.WARNING)
-        logging.getLogger('urllib3').setLevel(logging.WARNING)
-        logging.getLogger('s3transfer').setLevel(logging.WARNING)
+        logging.getLogger("boto3").setLevel(logging.WARNING)
+        logging.getLogger("botocore").setLevel(logging.WARNING)
+        logging.getLogger("urllib3").setLevel(logging.WARNING)
+        logging.getLogger("s3transfer").setLevel(logging.WARNING)
 
         bus = AsyncEventBus.get(transport=transport)
 

{mcp_agent → fast_agent/core}/logging/transport.py

@@ -17,11 +17,11 @@ from rich import print
 from rich.json import JSON
 from rich.text import Text
 
-from mcp_agent.config import LoggerSettings
-from mcp_agent.console import console
-from mcp_agent.logging.events import Event, EventFilter
-from mcp_agent.logging.json_serializer import JSONSerializer
-from mcp_agent.logging.listeners import EventListener, LifecycleAwareListener
+from fast_agent.config import LoggerSettings
+from fast_agent.core.logging.events import Event, EventFilter
+from fast_agent.core.logging.json_serializer import JSONSerializer
+from fast_agent.core.logging.listeners import EventListener, LifecycleAwareListener
+from fast_agent.ui.console import console
 
 
 class EventTransport(Protocol):
@@ -424,15 +424,14 @@ class AsyncEventBus:
                             )
 
             except asyncio.CancelledError:
-                # If we have a current event, mark it done before breaking
-                if event is not None:
+                # TODO -- added _queue assertion; is that necessary?
+                if event is not None and self._queue is not None:
                     self._queue.task_done()
-                break
+                raise
             except Exception as e:
                 print(f"Error in event processing loop: {e}")
-            finally:
-                # Always mark the task as done if we got an event
-                if event is not None:
+                # Mark task done for this event
+                if event is not None and self._queue is not None:
                     self._queue.task_done()
 
         # Process remaining events in queue

fast_agent/core/prompt.py

@@ -0,0 +1,9 @@
+"""
+Compatibility shim: expose Prompt under fast_agent.core.prompt during migration.
+
+Canonical location: fast_agent.mcp.prompt.Prompt
+"""
+
+from fast_agent.mcp.prompt import Prompt
+
+__all__ = ["Prompt"]

{mcp_agent → fast_agent}/core/validation.py

@@ -4,13 +4,13 @@ Validation utilities for FastAgent configuration and dependencies.
 
 from typing import Any, Dict, List
 
-from mcp_agent.core.agent_types import AgentType
-from mcp_agent.core.exceptions import (
+from fast_agent.agents.agent_types import AgentType
+from fast_agent.core.exceptions import (
     AgentConfigError,
     CircularDependencyError,
     ServerConfigError,
 )
-from mcp_agent.llm.augmented_llm import AugmentedLLM
+from fast_agent.llm.fastagent_llm import FastAgentLLM
 
 
 def validate_server_references(context, agents: Dict[str, Dict[str, Any]]) -> None:
@@ -96,7 +96,7 @@ def validate_workflow_references(agents: Dict[str, Dict[str, Any]]) -> None:
                 ]
 
                 if not (
-                    isinstance(func, AugmentedLLM)
+                    isinstance(func, FastAgentLLM)
                     or child_data["type"] in workflow_types
                     or (hasattr(func, "_llm") and func._llm is not None)
                 ):

fast_agent/event_progress.py

@@ -0,0 +1,61 @@
+"""Module for converting log events to progress events."""
+
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class ProgressAction(str, Enum):
+    """Progress actions available in the system."""
+
+    STARTING = "Starting"
+    LOADED = "Loaded"
+    INITIALIZED = "Initialized"
+    CHATTING = "Chatting"
+    STREAMING = "Streaming"  # Special action for real-time streaming updates
+    ROUTING = "Routing"
+    PLANNING = "Planning"
+    READY = "Ready"
+    CALLING_TOOL = "Calling Tool"
+    TOOL_PROGRESS = "Tool Progress"
+    UPDATED = "Updated"
+    FINISHED = "Finished"
+    SHUTDOWN = "Shutdown"
+    AGGREGATOR_INITIALIZED = "Running"
+    SERVER_OFFLINE = "Offline"
+    SERVER_RECONNECTING = "Reconnecting"
+    SERVER_ONLINE = "Online"
+    FATAL_ERROR = "Error"
+
+
+class ProgressEvent(BaseModel):
+    """Represents a progress event converted from a log event."""
+
+    action: ProgressAction
+    target: str
+    details: Optional[str] = None
+    agent_name: Optional[str] = None
+    streaming_tokens: Optional[str] = None  # Special field for streaming token count
+    progress: Optional[float] = None  # Current progress value
+    total: Optional[float] = None  # Total value for progress calculation
+
+    def __str__(self) -> str:
+        """Format the progress event for display."""
+        # Special handling for streaming - show token count in action position
+        if self.action == ProgressAction.STREAMING and self.streaming_tokens:
+            # For streaming, show just the token count instead of "Streaming"
+            action_display = self.streaming_tokens.ljust(11)
+            base = f"{action_display}. {self.target}"
+            if self.details:
+                base += f" - {self.details}"
+        else:
+            base = f"{self.action.ljust(11)}. {self.target}"
+            if self.details:
+                base += f" - {self.details}"
+        
+        if self.agent_name:
+            base = f"[{self.agent_name}] {base}"
+        return base
+
+

fast_agent/history/history_exporter.py

@@ -0,0 +1,44 @@
+"""
+History export utilities for agents.
+
+Provides a minimal, type-friendly way to save an agent's message history
+without using control strings. Uses the existing serialization helpers
+to choose JSON (for .json files) or Markdown-like delimited text otherwise.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from fast_agent.mcp.prompt_serialization import save_messages_to_file
+
+if TYPE_CHECKING:
+    from fast_agent.interfaces import AgentProtocol
+
+
+class HistoryExporter:
+    """Utility for exporting agent history to a file."""
+
+    @staticmethod
+    async def save(agent: AgentProtocol, filename: Optional[str] = None) -> str:
+        """
+        Save the given agent's message history to a file.
+
+        If filename ends with ".json", the history is saved in MCP JSON format.
+        Otherwise, it is saved in a human-readable Markdown-style format.
+
+        Args:
+            agent: The agent whose history will be saved.
+            filename: Optional filename. If None, a default name is chosen.
+
+        Returns:
+            The path that was written to.
+        """
+        # Determine a default filename when not provided
+        target = filename or f"{getattr(agent, 'name', 'assistant')}_prompts.txt"
+
+        messages = agent.message_history
+        save_messages_to_file(messages, target)
+
+        # Return and optionally print a small confirmation
+        return target

{mcp_agent → fast_agent}/human_input/__init__.py

@@ -1,14 +1,15 @@
-"""Human input modules for forms and elicitation."""
+"""Human input modules for forms and elicitation.
 
-# Export the simple form API
-# Export field types and schema builder
-from mcp_agent.human_input.form_fields import (
+Keep __init__ lightweight to avoid circular imports during submodule import.
+Exports schema builders directly and defers simple form API imports.
+"""
+
+from fast_agent.human_input.form_fields import (
     BooleanField,
     EnumField,
     FormSchema,
     IntegerField,
     NumberField,
-    # Field classes
     StringField,
     boolean,
     choice,
@@ -17,18 +18,11 @@ from mcp_agent.human_input.form_fields import (
     email,
     integer,
     number,
-    # Convenience functions
     string,
     url,
 )
-from mcp_agent.human_input.simple_form import ask, ask_sync, form, form_sync
 
 __all__ = [
-    # Form functions
-    "form",
-    "form_sync",
-    "ask",
-    "ask_sync",
     # Schema builder
     "FormSchema",
     # Field classes
@@ -48,3 +42,6 @@ __all__ = [
     "boolean",
     "choice",
 ]
+
+# Note: form(), ask() helpers are available via fast_agent.human_input.simple_form;
+# intentionally not imported here to avoid import-time cycles.

{mcp_agent → fast_agent}/human_input/elicitation_handler.py

@@ -1,17 +1,18 @@
 from typing import Any, Dict, Optional
 
-from mcp_agent.human_input.elicitation_form import (
+from fast_agent.human_input.elicitation_state import elicitation_state
+from fast_agent.human_input.types import (
+    HumanInputRequest,
+    HumanInputResponse,
+)
+from fast_agent.tools.elicitation import set_elicitation_input_callback
+from fast_agent.ui.elicitation_form import (
     show_simple_elicitation_form,
 )
-from mcp_agent.human_input.elicitation_forms import (
+from fast_agent.ui.elicitation_style import (
     ELICITATION_STYLE,
 )
-from mcp_agent.human_input.elicitation_state import elicitation_state
-from mcp_agent.human_input.types import (
-    HumanInputRequest,
-    HumanInputResponse,
-)
-from mcp_agent.progress_display import progress_display
+from fast_agent.ui.progress_display import progress_display
 
 
 async def elicitation_input_callback(
@@ -86,3 +87,20 @@ async def elicitation_input_callback(
         response=response.strip() if isinstance(response, str) else response,
         metadata={"has_schema": schema is not None},
     )
+
+
+# Register adapter with fast_agent tools so they can invoke this UI handler without importing types
+async def _elicitation_adapter(
+    request_payload: dict,
+    agent_name: str | None = None,
+    server_name: str | None = None,
+    server_info: dict[str, Any] | None = None,
+) -> str:
+    req = HumanInputRequest(**request_payload)
+    resp = await elicitation_input_callback(
+        request=req, agent_name=agent_name, server_name=server_name, server_info=server_info
+    )
+    return resp.response if isinstance(resp.response, str) else str(resp.response)
+
+
+set_elicitation_input_callback(_elicitation_adapter)

{mcp_agent → fast_agent}/human_input/elicitation_state.py

@@ -5,30 +5,30 @@ from typing import Set
 
 class ElicitationState:
     """Manages global state for elicitation requests, including disabled servers."""
-    
+
     def __init__(self):
         self.disabled_servers: Set[str] = set()
-    
+
     def disable_server(self, server_name: str) -> None:
         """Disable elicitation requests for a specific server."""
         self.disabled_servers.add(server_name)
-    
+
     def is_disabled(self, server_name: str) -> bool:
         """Check if elicitation is disabled for a server."""
         return server_name in self.disabled_servers
-    
+
     def enable_server(self, server_name: str) -> None:
         """Re-enable elicitation requests for a specific server."""
         self.disabled_servers.discard(server_name)
-    
+
     def clear_all(self) -> None:
         """Clear all disabled servers."""
         self.disabled_servers.clear()
-    
+
     def get_disabled_servers(self) -> Set[str]:
         """Get a copy of all disabled servers."""
         return self.disabled_servers.copy()
 
 
 # Global instance for session-scoped Cancel All functionality
-elicitation_state = ElicitationState()
+elicitation_state = ElicitationState()

{mcp_agent → fast_agent}/human_input/simple_form.py

@@ -5,8 +5,7 @@ from typing import Any, Dict, Optional, Union
 
 from mcp.types import ElicitRequestedSchema
 
-from mcp_agent.human_input.elicitation_form import show_simple_elicitation_form
-from mcp_agent.human_input.form_fields import FormSchema
+from fast_agent.human_input.form_fields import FormSchema
 
 
 async def form(
@@ -26,7 +25,7 @@ async def form(
         Dict with form data if accepted, None if cancelled/declined
 
     Example:
-        from mcp_agent.human_input.form_fields import FormSchema, string, email, integer
+        from fast_agent.human_input.form_fields import FormSchema, string, email, integer
 
         schema = FormSchema(
             name=string("Name", "Your full name", min_length=2),
@@ -46,6 +45,9 @@ async def form(
     else:
         elicit_schema = schema
 
+    # Import here to avoid import-time cycles via package __init__
+    from fast_agent.ui.elicitation_form import show_simple_elicitation_form
+
     # Show the form
     action, result = await show_simple_elicitation_form(
         schema=elicit_schema, message=message, agent_name=title, server_name="SimpleForm"
@@ -86,7 +88,7 @@ async def ask(
     Short alias for form() function.
 
     Example:
-        from mcp_agent.human_input.form_fields import FormSchema, string, email
+        from fast_agent.human_input.form_fields import FormSchema, string, email
 
         schema = FormSchema(
             name=string("Name", "Your name"),

{mcp_agent → fast_agent}/human_input/types.py

@@ -1,4 +1,4 @@
-from typing import Any, AsyncIterator, Protocol
+from typing import Any
 
 from pydantic import BaseModel
 
@@ -38,20 +38,3 @@ class HumanInputResponse(BaseModel):
 
     metadata: dict[str, Any] | None = None
     """Additional response payload"""
-
-
-class HumanInputCallback(Protocol):
-    """Protocol for callbacks that handle human input requests."""
-
-    async def __call__(self, request: HumanInputRequest) -> AsyncIterator[HumanInputResponse]:
-        """
-        Handle a human input request.
-
-        Args:
-            request: The input request to handle
-
-        Returns:
-            AsyncIterator yielding responses as they come in
-            TODO: saqadri - Keep it simple and just return HumanInputResponse?
-        """
-        ...