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

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/mcp/prompt_message_extended.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional
+from typing import Dict, List, Mapping, Optional, Sequence
 
 from mcp.types import (
     CallToolRequest,
@@ -27,7 +27,7 @@ class PromptMessageExtended(BaseModel):
     content: List[ContentBlock] = []
     tool_calls: Dict[str, CallToolRequest] | None = None
     tool_results: Dict[str, CallToolResult] | None = None
-    channels: Dict[str, List[ContentBlock]] | None = None
+    channels: Mapping[str, Sequence[ContentBlock]] | None = None
     stop_reason: LlmStopReason | None = None
 
     @classmethod

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}}."""
 
 

fast_agent/resources/setup/fastagent.config.yaml

@@ -16,9 +16,15 @@ default_model: gpt-5-mini.low
 # mcp_ui_mode: enabled
 
 # MCP timeline display (adjust activity window/intervals in MCP UI + fast-agent check)
-#mcp_timeline:
-#  steps: 20         # number of timeline buckets to render
-#  step_seconds: 30  # seconds per bucket (accepts values like "45s", "2m")
+mcp_timeline:
+  steps: 20 # number of timeline buckets to render
+  step_seconds: 15 # seconds per bucket (accepts values like "45s", "2m")
+
+#shell_execution:
+# length of time before terminating subprocess
+#  timeout_seconds: 20
+# warning interval if no output seen
+#  warning_seconds: 5
 
 # Logging and Console Configuration:
 logger:
@@ -28,13 +34,14 @@ logger:
 
   # Switch the progress display on or off
   progress_display: true
-
   # Show chat User/Assistant messages on the console
   show_chat: true
   # Show tool calls on the console
   show_tools: true
   # Truncate long tool responses on the console
   truncate_tools: true
+  # Streaming renderer for assistant responses: "markdown", "plain", or "none"
+  streaming: markdown
 
 # MCP Servers
 mcp:

fast_agent/skills/__init__.py

@@ -0,0 +1,9 @@
+"""Skill discovery utilities."""
+
+from .registry import SkillManifest, SkillRegistry, format_skills_for_prompt
+
+__all__ = [
+    "SkillManifest",
+    "SkillRegistry",
+    "format_skills_for_prompt",
+]