fast-agent-mcp 0.3.15__py3-none-any.whl → 0.3.16__py3-none-any.whl

fast_agent/core/logging/listeners.py

@@ -64,6 +64,14 @@ def convert_log_event(event: Event) -> "ProgressEvent | None":
         chat_turn = event_data.get("chat_turn")
         if chat_turn is not None:
             details = f"{model} turn {chat_turn}"
+
+        tool_name = event_data.get("tool_name")
+        tool_event = event_data.get("tool_event")
+        if tool_name:
+            tool_suffix = tool_name
+            if tool_event:
+                tool_suffix = f"{tool_suffix} ({tool_event})"
+            details = f"{details} • {tool_suffix}".strip()
     else:
         if not target:
             target = event_data.get("target", "unknown")

fast_agent/interfaces.py

@@ -87,9 +87,15 @@ class FastAgentLLMProtocol(Protocol):
 
     def add_stream_listener(self, listener: Callable[[str], None]) -> Callable[[], None]: ...
 
+    def add_tool_stream_listener(
+        self, listener: Callable[[str, Dict[str, Any] | None], None]
+    ) -> Callable[[], None]: ...
+
     @property
     def message_history(self) -> List[PromptMessageExtended]: ...
 
+    def pop_last_message(self) -> PromptMessageExtended | None: ...
+
     @property
     def usage_accumulator(self) -> UsageAccumulator | None: ...
 
@@ -123,6 +129,8 @@ class LlmAgentProtocol(Protocol):
 
     def clear(self, *, clear_prompts: bool = False) -> None: ...
 
+    def pop_last_message(self) -> PromptMessageExtended | None: ...
+
 
 class AgentProtocol(LlmAgentProtocol, Protocol):
     """Standard agent interface with flexible input types."""

fast_agent/llm/fastagent_llm.py

@@ -159,6 +159,7 @@ class FastAgentLLM(ContextDependent, FastAgentLLMProtocol, Generic[MessageParamT
         # Initialize usage tracking
         self._usage_accumulator = UsageAccumulator()
         self._stream_listeners: set[Callable[[str], None]] = set()
+        self._tool_stream_listeners: set[Callable[[str, Dict[str, Any] | None], None]] = set()
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize default parameters for the LLM.
@@ -534,6 +535,37 @@ class FastAgentLLM(ContextDependent, FastAgentLLMProtocol, Generic[MessageParamT
             except Exception:
                 self.logger.exception("Stream listener raised an exception")
 
+    def add_tool_stream_listener(
+        self, listener: Callable[[str, Dict[str, Any] | None], None]
+    ) -> Callable[[], None]:
+        """Register a callback invoked with tool streaming events.
+
+        Args:
+            listener: Callable receiving event_type (str) and optional info dict.
+
+        Returns:
+            A function that removes the listener when called.
+        """
+
+        self._tool_stream_listeners.add(listener)
+
+        def remove() -> None:
+            self._tool_stream_listeners.discard(listener)
+
+        return remove
+
+    def _notify_tool_stream_listeners(
+        self, event_type: str, payload: Dict[str, Any] | None = None
+    ) -> None:
+        """Notify listeners about tool streaming lifecycle events."""
+
+        data = payload or {}
+        for listener in list(self._tool_stream_listeners):
+            try:
+                listener(event_type, data)
+            except Exception:
+                self.logger.exception("Tool stream listener raised an exception")
+
     def _log_chat_finished(self, model: Optional[str] = None) -> None:
         """Log a chat finished event"""
         data = {
@@ -643,6 +675,19 @@ class FastAgentLLM(ContextDependent, FastAgentLLMProtocol, Generic[MessageParamT
         """
         return self._message_history
 
+    def pop_last_message(self) -> PromptMessageExtended | None:
+        """Remove and return the most recent message from the conversation history."""
+        if not self._message_history:
+            return None
+
+        removed = self._message_history.pop()
+        try:
+            self.history.pop()
+        except Exception:
+            # If provider-specific memory isn't available, ignore to avoid crashing UX
+            pass
+        return removed
+
     def clear(self, *, clear_prompts: bool = False) -> None:
         """Reset stored message history while optionally retaining prompt templates."""
 

fast_agent/llm/memory.py

@@ -1,4 +1,4 @@
-from typing import Generic, List, Protocol, TypeVar
+from typing import Generic, List, Optional, Protocol, TypeVar
 
 # Define our own type variable for implementation use
 MessageParamT = TypeVar("MessageParamT")
@@ -23,6 +23,8 @@ class Memory(Protocol, Generic[MessageParamT]):
 
     def clear(self, clear_prompts: bool = False) -> None: ...
 
+    def pop(self, *, from_prompts: bool = False) -> Optional[MessageParamT]: ...
+
 
 class SimpleMemory(Memory, Generic[MessageParamT]):
     """
@@ -108,6 +110,29 @@ class SimpleMemory(Memory, Generic[MessageParamT]):
         if clear_prompts:
             self.prompt_messages = []
 
+    def pop(self, *, from_prompts: bool = False) -> Optional[MessageParamT]:
+        """
+        Remove and return the most recent message from history or prompt messages.
+
+        Args:
+            from_prompts: If True, pop from prompt_messages instead of history
+
+        Returns:
+            The removed message if available, otherwise None
+        """
+        if from_prompts:
+            if not self.prompt_messages:
+                return None
+            return self.prompt_messages.pop()
+
+        if not self.history:
+            return None
+
+        removed = self.history.pop()
+        # Recalculate cache positions now that the history shrank
+        self.conversation_cache_positions = self._calculate_cache_positions(len(self.history))
+        return removed
+
     def should_apply_conversation_cache(self) -> bool:
         """
         Determine if conversation caching should be applied based on walking algorithm.

fast_agent/llm/provider/anthropic/llm_anthropic.py

@@ -244,10 +244,114 @@ class AnthropicLLM(FastAgentLLM[MessageParam, Message]):
         """Process the streaming response and display real-time token usage."""
         # Track estimated output tokens by counting text chunks
         estimated_tokens = 0
+        tool_streams: dict[int, dict[str, Any]] = {}
 
         try:
             # Process the raw event stream to get token counts
             async for event in stream:
+                if (
+                    event.type == "content_block_start"
+                    and hasattr(event, "content_block")
+                    and getattr(event.content_block, "type", None) == "tool_use"
+                ):
+                    content_block = event.content_block
+                    tool_streams[event.index] = {
+                        "name": content_block.name,
+                        "id": content_block.id,
+                        "buffer": [],
+                    }
+                    self._notify_tool_stream_listeners(
+                        "start",
+                        {
+                            "tool_name": content_block.name,
+                            "tool_use_id": content_block.id,
+                            "index": event.index,
+                            "streams_arguments": False,  # Anthropic doesn't stream arguments
+                        },
+                    )
+                    self.logger.info(
+                        "Model started streaming tool input",
+                        data={
+                            "progress_action": ProgressAction.CALLING_TOOL,
+                            "agent_name": self.name,
+                            "model": model,
+                            "tool_name": content_block.name,
+                            "tool_use_id": content_block.id,
+                            "tool_event": "start",
+                        },
+                    )
+                    continue
+
+                if (
+                    event.type == "content_block_delta"
+                    and hasattr(event, "delta")
+                    and event.delta.type == "input_json_delta"
+                ):
+                    info = tool_streams.get(event.index)
+                    if info is not None:
+                        chunk = event.delta.partial_json or ""
+                        info["buffer"].append(chunk)
+                        preview = chunk if len(chunk) <= 80 else chunk[:77] + "..."
+                        self._notify_tool_stream_listeners(
+                            "delta",
+                            {
+                                "tool_name": info.get("name"),
+                                "tool_use_id": info.get("id"),
+                                "index": event.index,
+                                "chunk": chunk,
+                                "streams_arguments": False,
+                            },
+                        )
+                        self.logger.debug(
+                            "Streaming tool input delta",
+                            data={
+                                "tool_name": info.get("name"),
+                                "tool_use_id": info.get("id"),
+                                "chunk": preview,
+                            },
+                        )
+                    continue
+
+                if (
+                    event.type == "content_block_stop"
+                    and event.index in tool_streams
+                ):
+                    info = tool_streams.pop(event.index)
+                    preview_raw = "".join(info.get("buffer", []))
+                    if preview_raw:
+                        preview = (
+                            preview_raw if len(preview_raw) <= 120 else preview_raw[:117] + "..."
+                        )
+                        self.logger.debug(
+                            "Completed tool input stream",
+                            data={
+                                "tool_name": info.get("name"),
+                                "tool_use_id": info.get("id"),
+                                "input_preview": preview,
+                            },
+                        )
+                    self._notify_tool_stream_listeners(
+                        "stop",
+                        {
+                            "tool_name": info.get("name"),
+                            "tool_use_id": info.get("id"),
+                            "index": event.index,
+                            "streams_arguments": False,
+                        },
+                    )
+                    self.logger.info(
+                        "Model finished streaming tool input",
+                        data={
+                            "progress_action": ProgressAction.CALLING_TOOL,
+                            "agent_name": self.name,
+                            "model": model,
+                            "tool_name": info.get("name"),
+                            "tool_use_id": info.get("id"),
+                            "tool_event": "stop",
+                        },
+                    )
+                    continue
+
                 # Count tokens in real-time from content_block_delta events
                 if (
                     event.type == "content_block_delta"
@@ -258,6 +362,14 @@ class AnthropicLLM(FastAgentLLM[MessageParam, Message]):
                     estimated_tokens = self._update_streaming_progress(
                         event.delta.text, model, estimated_tokens
                     )
+                    self._notify_tool_stream_listeners(
+                        "text",
+                        {
+                            "chunk": event.delta.text,
+                            "index": event.index,
+                            "streams_arguments": False,
+                        },
+                    )
 
                 # Also check for final message_delta events with actual usage info
                 elif (

fast_agent/llm/provider/openai/llm_openai.py

@@ -7,7 +7,7 @@ from mcp.types import (
     ContentBlock,
     TextContent,
 )
-from openai import APIError, AsyncOpenAI, AuthenticationError
+from openai import APIError, AsyncOpenAI, AuthenticationError, DefaultAioHttpClient
 from openai.lib.streaming.chat import ChatCompletionStreamState
 
 # from openai.types.beta.chat import
@@ -95,9 +95,19 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
         return self.context.config.openai.base_url if self.context.config.openai else None
 
     def _openai_client(self) -> AsyncOpenAI:
-        try:
-            return AsyncOpenAI(api_key=self._api_key(), base_url=self._base_url())
+        """
+        Create an OpenAI client instance.
+        Subclasses can override this to provide different client types (e.g., AzureOpenAI).
 
+        Note: The returned client should be used within an async context manager
+        to ensure proper cleanup of aiohttp sessions.
+        """
+        try:
+            return AsyncOpenAI(
+                api_key=self._api_key(),
+                base_url=self._base_url(),
+                http_client=DefaultAioHttpClient(),
+            )
         except AuthenticationError as e:
             raise ProviderKeyError(
                 "Invalid OpenAI API key",
@@ -119,16 +129,93 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
         # Use ChatCompletionStreamState helper for accumulation (OpenAI only)
         state = ChatCompletionStreamState()
 
+        # Track tool call state for stream events
+        tool_call_started = {}  # Maps index -> bool for tracking start events
+
         # Process the stream chunks
         async for chunk in stream:
             # Handle chunk accumulation
             state.handle_chunk(chunk)
 
-            # Count tokens in real-time from content deltas
-            if chunk.choices and chunk.choices[0].delta.content:
-                content = chunk.choices[0].delta.content
-                # Use base class method for token estimation and progress emission
-                estimated_tokens = self._update_streaming_progress(content, model, estimated_tokens)
+            # Process streaming events for tool calls
+            if chunk.choices:
+                choice = chunk.choices[0]
+                delta = choice.delta
+
+                # Handle tool call streaming
+                if delta.tool_calls:
+                    for tool_call in delta.tool_calls:
+                        index = tool_call.index
+
+                        # Fire "start" event on first chunk for this tool call
+                        if index not in tool_call_started and tool_call.id and tool_call.function and tool_call.function.name:
+                            tool_call_started[index] = True
+                            self._notify_tool_stream_listeners(
+                                "start",
+                                {
+                                    "tool_name": tool_call.function.name,
+                                    "tool_use_id": tool_call.id,
+                                    "index": index,
+                                    "streams_arguments": True,  # OpenAI streams arguments!
+                                },
+                            )
+                            self.logger.info(
+                                "Model started streaming tool call",
+                                data={
+                                    "progress_action": ProgressAction.CALLING_TOOL,
+                                    "agent_name": self.name,
+                                    "model": model,
+                                    "tool_name": tool_call.function.name,
+                                    "tool_use_id": tool_call.id,
+                                    "tool_event": "start",
+                                },
+                            )
+
+                        # Fire "delta" event for argument chunks
+                        if tool_call.function and tool_call.function.arguments:
+                            self._notify_tool_stream_listeners(
+                                "delta",
+                                {
+                                    "tool_name": tool_call.function.name if tool_call.function.name else None,
+                                    "tool_use_id": tool_call.id,
+                                    "index": index,
+                                    "chunk": tool_call.function.arguments,
+                                    "streams_arguments": True,
+                                },
+                            )
+
+                # Handle text content streaming
+                if delta.content:
+                    content = delta.content
+                    # Use base class method for token estimation and progress emission
+                    estimated_tokens = self._update_streaming_progress(content, model, estimated_tokens)
+                    self._notify_tool_stream_listeners(
+                        "text",
+                        {
+                            "chunk": content,
+                            "streams_arguments": True,
+                        },
+                    )
+
+                # Fire "stop" event when tool calls complete
+                if choice.finish_reason == "tool_calls":
+                    for index in tool_call_started.keys():
+                        self._notify_tool_stream_listeners(
+                            "stop",
+                            {
+                                "index": index,
+                                "streams_arguments": True,
+                            },
+                        )
+                        self.logger.info(
+                            "Model finished streaming tool call",
+                            data={
+                                "progress_action": ProgressAction.CALLING_TOOL,
+                                "agent_name": self.name,
+                                "model": model,
+                                "tool_event": "stop",
+                            },
+                        )
 
         # Check if we hit the length limit to avoid LengthFinishReasonError
         current_snapshot = state.current_completion_snapshot
@@ -176,14 +263,92 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
         finish_reason = None
         usage_data = None
 
+        # Track tool call state for stream events
+        tool_call_started = {}  # Maps index -> bool for tracking start events
+
         # Process the stream chunks manually
         async for chunk in stream:
-            # Count tokens in real-time from content deltas
-            if chunk.choices and chunk.choices[0].delta.content:
-                content = chunk.choices[0].delta.content
-                accumulated_content += content
-                # Use base class method for token estimation and progress emission
-                estimated_tokens = self._update_streaming_progress(content, model, estimated_tokens)
+            # Process streaming events for tool calls
+            if chunk.choices:
+                choice = chunk.choices[0]
+                delta = choice.delta
+
+                # Handle tool call streaming
+                if delta.tool_calls:
+                    for tool_call in delta.tool_calls:
+                        if tool_call.index is not None:
+                            index = tool_call.index
+
+                            # Fire "start" event on first chunk for this tool call
+                            if index not in tool_call_started and tool_call.id and tool_call.function and tool_call.function.name:
+                                tool_call_started[index] = True
+                                self._notify_tool_stream_listeners(
+                                    "start",
+                                    {
+                                        "tool_name": tool_call.function.name,
+                                        "tool_use_id": tool_call.id,
+                                        "index": index,
+                                        "streams_arguments": True,  # OpenAI-compatible providers stream arguments
+                                    },
+                                )
+                                self.logger.info(
+                                    "Model started streaming tool call",
+                                    data={
+                                        "progress_action": ProgressAction.CALLING_TOOL,
+                                        "agent_name": self.name,
+                                        "model": model,
+                                        "tool_name": tool_call.function.name,
+                                        "tool_use_id": tool_call.id,
+                                        "tool_event": "start",
+                                    },
+                                )
+
+                            # Fire "delta" event for argument chunks
+                            if tool_call.function and tool_call.function.arguments:
+                                self._notify_tool_stream_listeners(
+                                    "delta",
+                                    {
+                                        "tool_name": tool_call.function.name if tool_call.function.name else None,
+                                        "tool_use_id": tool_call.id,
+                                        "index": index,
+                                        "chunk": tool_call.function.arguments,
+                                        "streams_arguments": True,
+                                    },
+                                )
+
+                # Handle text content streaming
+                if delta.content:
+                    content = delta.content
+                    accumulated_content += content
+                    # Use base class method for token estimation and progress emission
+                    estimated_tokens = self._update_streaming_progress(content, model, estimated_tokens)
+                    self._notify_tool_stream_listeners(
+                        "text",
+                        {
+                            "chunk": content,
+                            "streams_arguments": True,
+                        },
+                    )
+
+                # Fire "stop" event when tool calls complete
+                if choice.finish_reason == "tool_calls":
+                    for index in tool_call_started.keys():
+                        self._notify_tool_stream_listeners(
+                            "stop",
+                            {
+                                "index": index,
+                                "streams_arguments": True,
+                            },
+                        )
+                        self.logger.info(
+                            "Model finished streaming tool call",
+                            data={
+                                "progress_action": ProgressAction.CALLING_TOOL,
+                                "agent_name": self.name,
+                                "model": model,
+                                "tool_event": "stop",
+                            },
+                        )
 
             # Extract other fields from the chunk
             if chunk.choices:
@@ -343,11 +508,12 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
         self._log_chat_progress(self.chat_turn(), model=self.default_request_params.model)
         model_name = self.default_request_params.model or DEFAULT_OPENAI_MODEL
 
-        # Use basic streaming API
+        # Use basic streaming API with context manager to properly close aiohttp session
         try:
-            stream = await self._openai_client().chat.completions.create(**arguments)
-            # Process the stream
-            response = await self._process_stream(stream, model_name)
+            async with self._openai_client() as client:
+                stream = await client.chat.completions.create(**arguments)
+                # Process the stream
+                response = await self._process_stream(stream, model_name)
         except APIError as error:
             self.logger.error("APIError during OpenAI completion", exc_info=error)
             return self._stream_failure_response(error, model_name)

fast_agent/llm/provider/openai/responses.py

@@ -0,0 +1,133 @@
+# from openai.types.beta.chat import
+from typing import List
+
+from mcp import Tool
+from mcp.types import ContentBlock, TextContent
+from openai import AsyncOpenAI
+from openai.types.chat import (
+    ChatCompletionMessage,
+    ChatCompletionMessageParam,
+)
+from openai.types.responses import (
+    ResponseReasoningItem,
+    ResponseReasoningSummaryTextDeltaEvent,
+    ResponseTextDeltaEvent,
+)
+
+from fast_agent.constants import REASONING
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.event_progress import ProgressAction
+from fast_agent.llm.fastagent_llm import FastAgentLLM
+from fast_agent.llm.provider_types import Provider
+from fast_agent.llm.request_params import RequestParams
+from fast_agent.mcp.prompt_message_extended import PromptMessageExtended
+from fast_agent.types.llm_stop_reason import LlmStopReason
+
+_logger = get_logger(__name__)
+
+DEFAULT_RESPONSES_MODEL = "gpt-5-mini"
+DEFAULT_REASONING_EFFORT = "medium"
+
+
+# model selection
+# system prompt
+# usage info
+# reasoning/thinking display and summary
+# encrypted tokens
+
+
+class ResponsesLLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage]):
+    """LLM implementation for OpenAI's Responses models."""
+
+    # OpenAI-specific parameter exclusions
+
+    def __init__(self, provider=Provider.RESPONSES, *args, **kwargs):
+        super().__init__(*args, provider=provider, **kwargs)
+
+    async def _responses_client(self) -> AsyncOpenAI:
+        return AsyncOpenAI(api_key=self._api_key())
+
+    async def _apply_prompt_provider_specific(
+        self,
+        multipart_messages: List[PromptMessageExtended],
+        request_params: RequestParams | None = None,
+        tools: List[Tool] | None = None,
+        is_template: bool = False,
+    ) -> PromptMessageExtended:
+        responses_client = await self._responses_client()
+
+        async with responses_client.responses.stream(
+            model="gpt-5-mini",
+            instructions="You are a helpful assistant.",
+            input=multipart_messages[-1].all_text(),
+            reasoning={"summary": "auto", "effort": DEFAULT_REASONING_EFFORT},
+        ) as stream:
+            reasoning_chars: int = 0
+            text_chars: int = 0
+
+            async for event in stream:
+                if isinstance(event, ResponseReasoningSummaryTextDeltaEvent):
+                    reasoning_chars += len(event.delta)
+                    await self._emit_streaming_progress(
+                        model="gpt-5-mini (thinking)",
+                        new_total=reasoning_chars,
+                        type=ProgressAction.THINKING,
+                    )
+                if isinstance(event, ResponseTextDeltaEvent):
+                    # Notify stream listeners with the delta text
+                    self._notify_stream_listeners(event.delta)
+                    text_chars += len(event.delta)
+                    await self._emit_streaming_progress(
+                        model="gpt-5-mini",
+                        new_total=text_chars,
+                    )
+
+            final_response = await stream.get_final_response()
+            reasoning_content: List[ContentBlock] = []
+            for output_item in final_response.output:
+                if isinstance(output_item, ResponseReasoningItem):
+                    summary_text = "\n".join(part.text for part in output_item.summary if part.text)
+                    # reasoning text is not supplied by openai - leaving for future use with other providers
+                    reasoning_text = "".join(
+                        chunk.text
+                        for chunk in (output_item.content or [])
+                        if chunk.type == "reasoning_text"
+                    )
+                    if summary_text.strip():
+                        reasoning_content.append(TextContent(type="text", text=summary_text.strip()))
+                    if reasoning_text.strip():
+                        reasoning_content.append(
+                            TextContent(type="text", text=reasoning_text.strip())
+                        )
+        channels = {REASONING: reasoning_content} if reasoning_content else None
+
+        return PromptMessageExtended(
+            role="assistant",
+            channels=channels,
+            content=[TextContent(type="text", text=final_response.output_text)],
+            stop_reason=LlmStopReason.END_TURN,
+        )
+
+    async def _emit_streaming_progress(
+        self,
+        model: str,
+        new_total: int,
+        type: ProgressAction = ProgressAction.STREAMING,
+    ) -> None:
+        """Emit a streaming progress event.
+
+        Args:
+            model: The model being used.
+            new_total: The new total token count.
+        """
+        token_str = str(new_total).rjust(5)
+
+        # Emit progress event
+        data = {
+            "progress_action": type,
+            "model": model,
+            "agent_name": self.name,
+            "chat_turn": self.chat_turn(),
+            "details": token_str.strip(),  # Token count goes in details for STREAMING action
+        }
+        self.logger.info("Streaming progress", data=data)

fast_agent/resources/setup/agent.py

@@ -10,6 +10,8 @@ default_instruction = """You are a helpful AI Agent.
 
 {{serverInstructions}}
 
+{{agentSkills}}
+
 The current date is {{currentDate}}."""