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

fast_agent/llm/provider/openai/llm_openai.py

@@ -115,6 +115,96 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
                 "Please check that your API key is valid and not expired.",
             ) from e
 
+    def _streams_tool_arguments(self) -> bool:
+        """
+        Determine whether the current provider streams tool call arguments incrementally.
+
+        Official OpenAI and Azure OpenAI endpoints stream arguments. Most third-party
+        OpenAI-compatible gateways (e.g. OpenRouter, Moonshot) deliver the full arguments
+        once, so we should treat them as non-streaming to restore the legacy \"Calling Tool\"
+        display experience.
+        """
+        if self.provider == Provider.AZURE:
+            return True
+
+        if self.provider == Provider.OPENAI:
+            base_url = self._base_url()
+            if not base_url:
+                return True
+            lowered = base_url.lower()
+            return "api.openai" in lowered or "openai.azure" in lowered or "azure.com" in lowered
+
+        return False
+
+    def _emit_tool_notification_fallback(
+        self,
+        tool_calls: Any,
+        notified_indices: set[int],
+        *,
+        streams_arguments: bool,
+        model: str,
+    ) -> None:
+        """Emit start/stop notifications when streaming metadata was missing."""
+        if not tool_calls:
+            return
+
+        for index, tool_call in enumerate(tool_calls):
+            if index in notified_indices:
+                continue
+
+            tool_name = None
+            tool_use_id = None
+
+            try:
+                tool_use_id = getattr(tool_call, "id", None)
+                function = getattr(tool_call, "function", None)
+                if function:
+                    tool_name = getattr(function, "name", None)
+            except Exception:
+                tool_use_id = None
+                tool_name = None
+
+            if not tool_name:
+                tool_name = "tool"
+            if not tool_use_id:
+                tool_use_id = f"tool-{index}"
+
+            payload = {
+                "tool_name": tool_name,
+                "tool_use_id": tool_use_id,
+                "index": index,
+                "streams_arguments": streams_arguments,
+            }
+
+            self._notify_tool_stream_listeners("start", payload)
+            self.logger.info(
+                "Model emitted fallback tool notification",
+                data={
+                    "progress_action": ProgressAction.CALLING_TOOL,
+                    "agent_name": self.name,
+                    "model": model,
+                    "tool_name": tool_name,
+                    "tool_use_id": tool_use_id,
+                    "tool_event": "start",
+                    "streams_arguments": streams_arguments,
+                    "fallback": True,
+                },
+            )
+            self._notify_tool_stream_listeners("stop", payload)
+            self.logger.info(
+                "Model emitted fallback tool notification",
+                data={
+                    "progress_action": ProgressAction.CALLING_TOOL,
+                    "agent_name": self.name,
+                    "model": model,
+                    "tool_name": tool_name,
+                    "tool_use_id": tool_use_id,
+                    "tool_event": "stop",
+                    "streams_arguments": streams_arguments,
+                    "fallback": True,
+                },
+            )
+
     async def _process_stream(self, stream, model: str):
         """Process the streaming response and display real-time token usage."""
         # Track estimated output tokens by counting text chunks
@@ -123,20 +213,25 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
         # For non-OpenAI providers (like Ollama), ChatCompletionStreamState might not work correctly
         # Fall back to manual accumulation if needed
         # TODO -- consider this and whether to subclass instead
-        if self.provider in [Provider.GENERIC, Provider.OPENROUTER, Provider.GOOGLE_OAI]:
+        if self.provider in [
+            Provider.GENERIC,
+            Provider.OPENROUTER,
+            Provider.GOOGLE_OAI,
+        ]:
             return await self._process_stream_manual(stream, model)
 
         # 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
+        tool_call_started: dict[int, dict[str, Any]] = {}
+        streams_arguments = self._streams_tool_arguments()
+        notified_tool_indices: set[int] = set()
 
         # Process the stream chunks
         async for chunk in stream:
             # Handle chunk accumulation
             state.handle_chunk(chunk)
-
             # Process streaming events for tool calls
             if chunk.choices:
                 choice = chunk.choices[0]
@@ -148,15 +243,32 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
                         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
+                        if index is None:
+                            continue
+
+                        existing_info = tool_call_started.get(index)
+                        tool_use_id = tool_call.id or (
+                            existing_info.get("tool_use_id") if existing_info else None
+                        )
+                        function_name = (
+                            tool_call.function.name
+                            if tool_call.function and tool_call.function.name
+                            else (existing_info.get("tool_name") if existing_info else None)
+                        )
+
+                        if existing_info is None and tool_use_id and function_name:
+                            tool_call_started[index] = {
+                                "tool_name": function_name,
+                                "tool_use_id": tool_use_id,
+                                "streams_arguments": streams_arguments,
+                            }
                             self._notify_tool_stream_listeners(
                                 "start",
                                 {
-                                    "tool_name": tool_call.function.name,
-                                    "tool_use_id": tool_call.id,
+                                    "tool_name": function_name,
+                                    "tool_use_id": tool_use_id,
                                     "index": index,
-                                    "streams_arguments": True,  # OpenAI streams arguments!
+                                    "streams_arguments": streams_arguments,
                                 },
                             )
                             self.logger.info(
@@ -165,22 +277,37 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
                                     "progress_action": ProgressAction.CALLING_TOOL,
                                     "agent_name": self.name,
                                     "model": model,
-                                    "tool_name": tool_call.function.name,
-                                    "tool_use_id": tool_call.id,
+                                    "tool_name": function_name,
+                                    "tool_use_id": tool_use_id,
                                     "tool_event": "start",
+                                    "streams_arguments": streams_arguments,
                                 },
                             )
+                            notified_tool_indices.add(index)
+                        elif existing_info:
+                            if tool_use_id:
+                                existing_info["tool_use_id"] = tool_use_id
+                            if function_name:
+                                existing_info["tool_name"] = function_name
 
                         # Fire "delta" event for argument chunks
                         if tool_call.function and tool_call.function.arguments:
+                            info = tool_call_started.setdefault(
+                                index,
+                                {
+                                    "tool_name": function_name,
+                                    "tool_use_id": tool_use_id,
+                                    "streams_arguments": streams_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,
+                                    "tool_name": info.get("tool_name"),
+                                    "tool_use_id": info.get("tool_use_id"),
                                     "index": index,
                                     "chunk": tool_call.function.arguments,
-                                    "streams_arguments": True,
+                                    "streams_arguments": info.get("streams_arguments", False),
                                 },
                             )
 
@@ -188,23 +315,27 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
                 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)
+                    estimated_tokens = self._update_streaming_progress(
+                        content, model, estimated_tokens
+                    )
                     self._notify_tool_stream_listeners(
                         "text",
                         {
                             "chunk": content,
-                            "streams_arguments": True,
+                            "streams_arguments": streams_arguments,
                         },
                     )
 
                 # Fire "stop" event when tool calls complete
                 if choice.finish_reason == "tool_calls":
-                    for index in tool_call_started.keys():
+                    for index, info in list(tool_call_started.items()):
                         self._notify_tool_stream_listeners(
                             "stop",
                             {
+                                "tool_name": info.get("tool_name"),
+                                "tool_use_id": info.get("tool_use_id"),
                                 "index": index,
-                                "streams_arguments": True,
+                                "streams_arguments": info.get("streams_arguments", False),
                             },
                         )
                         self.logger.info(
@@ -213,9 +344,14 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
                                 "progress_action": ProgressAction.CALLING_TOOL,
                                 "agent_name": self.name,
                                 "model": model,
+                                "tool_name": info.get("tool_name"),
+                                "tool_use_id": info.get("tool_use_id"),
                                 "tool_event": "stop",
+                                "streams_arguments": info.get("streams_arguments", False),
                             },
                         )
+                        notified_tool_indices.add(index)
+                    tool_call_started.clear()
 
         # Check if we hit the length limit to avoid LengthFinishReasonError
         current_snapshot = state.current_completion_snapshot
@@ -244,12 +380,24 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
                 f"Streaming complete - Model: {model}, Input tokens: {final_completion.usage.prompt_tokens}, Output tokens: {final_completion.usage.completion_tokens}"
             )
 
+        final_message = None
+        if hasattr(final_completion, "choices") and final_completion.choices:
+            final_message = getattr(final_completion.choices[0], "message", None)
+        tool_calls = getattr(final_message, "tool_calls", None) if final_message else None
+        self._emit_tool_notification_fallback(
+            tool_calls,
+            notified_tool_indices,
+            streams_arguments=streams_arguments,
+            model=model,
+        )
+
         return final_completion
 
     # TODO - as per other comment this needs to go in another class. There are a number of "special" cases dealt with
     # here to deal with OpenRouter idiosyncrasies between e.g. Anthropic and Gemini models.
     async def _process_stream_manual(self, stream, model: str):
         """Manual stream processing for providers like Ollama that may not work with ChatCompletionStreamState."""
+
         from openai.types.chat import ChatCompletionMessageToolCall
 
         # Track estimated output tokens by counting text chunks
@@ -264,7 +412,9 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
         usage_data = None
 
         # Track tool call state for stream events
-        tool_call_started = {}  # Maps index -> bool for tracking start events
+        tool_call_started: dict[int, dict[str, Any]] = {}
+        streams_arguments = self._streams_tool_arguments()
+        notified_tool_indices: set[int] = set()
 
         # Process the stream chunks manually
         async for chunk in stream:
@@ -279,16 +429,30 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
                         if tool_call.index is not None:
                             index = tool_call.index
 
+                            existing_info = tool_call_started.get(index)
+                            tool_use_id = tool_call.id or (
+                                existing_info.get("tool_use_id") if existing_info else None
+                            )
+                            function_name = (
+                                tool_call.function.name
+                                if tool_call.function and tool_call.function.name
+                                else (existing_info.get("tool_name") if existing_info else None)
+                            )
+
                             # 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
+                            if index not in tool_call_started and tool_use_id and function_name:
+                                tool_call_started[index] = {
+                                    "tool_name": function_name,
+                                    "tool_use_id": tool_use_id,
+                                    "streams_arguments": streams_arguments,
+                                }
                                 self._notify_tool_stream_listeners(
                                     "start",
                                     {
-                                        "tool_name": tool_call.function.name,
-                                        "tool_use_id": tool_call.id,
+                                        "tool_name": function_name,
+                                        "tool_use_id": tool_use_id,
                                         "index": index,
-                                        "streams_arguments": True,  # OpenAI-compatible providers stream arguments
+                                        "streams_arguments": streams_arguments,
                                     },
                                 )
                                 self.logger.info(
@@ -297,22 +461,37 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
                                         "progress_action": ProgressAction.CALLING_TOOL,
                                         "agent_name": self.name,
                                         "model": model,
-                                        "tool_name": tool_call.function.name,
-                                        "tool_use_id": tool_call.id,
+                                        "tool_name": function_name,
+                                        "tool_use_id": tool_use_id,
                                         "tool_event": "start",
+                                        "streams_arguments": streams_arguments,
                                     },
                                 )
+                                notified_tool_indices.add(index)
+                            elif existing_info:
+                                if tool_use_id:
+                                    existing_info["tool_use_id"] = tool_use_id
+                                if function_name:
+                                    existing_info["tool_name"] = function_name
 
                             # Fire "delta" event for argument chunks
                             if tool_call.function and tool_call.function.arguments:
+                                info = tool_call_started.setdefault(
+                                    index,
+                                    {
+                                        "tool_name": function_name,
+                                        "tool_use_id": tool_use_id,
+                                        "streams_arguments": streams_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,
+                                        "tool_name": info.get("tool_name"),
+                                        "tool_use_id": info.get("tool_use_id"),
                                         "index": index,
                                         "chunk": tool_call.function.arguments,
-                                        "streams_arguments": True,
+                                        "streams_arguments": info.get("streams_arguments", False),
                                     },
                                 )
 
@@ -321,23 +500,27 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
                     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)
+                    estimated_tokens = self._update_streaming_progress(
+                        content, model, estimated_tokens
+                    )
                     self._notify_tool_stream_listeners(
                         "text",
                         {
                             "chunk": content,
-                            "streams_arguments": True,
+                            "streams_arguments": streams_arguments,
                         },
                     )
 
                 # Fire "stop" event when tool calls complete
                 if choice.finish_reason == "tool_calls":
-                    for index in tool_call_started.keys():
+                    for index, info in list(tool_call_started.items()):
                         self._notify_tool_stream_listeners(
                             "stop",
                             {
+                                "tool_name": info.get("tool_name"),
+                                "tool_use_id": info.get("tool_use_id"),
                                 "index": index,
-                                "streams_arguments": True,
+                                "streams_arguments": info.get("streams_arguments", False),
                             },
                         )
                         self.logger.info(
@@ -346,9 +529,14 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
                                 "progress_action": ProgressAction.CALLING_TOOL,
                                 "agent_name": self.name,
                                 "model": model,
+                                "tool_name": info.get("tool_name"),
+                                "tool_use_id": info.get("tool_use_id"),
                                 "tool_event": "stop",
+                                "streams_arguments": info.get("streams_arguments", False),
                             },
                         )
+                        notified_tool_indices.add(index)
+                    tool_call_started.clear()
 
             # Extract other fields from the chunk
             if chunk.choices:
@@ -449,6 +637,15 @@ class OpenAILLM(FastAgentLLM[ChatCompletionMessageParam, ChatCompletionMessage])
                 f"Streaming complete - Model: {model}, Input tokens: {getattr(usage_data, 'prompt_tokens', 0)}, Output tokens: {actual_tokens}"
             )
 
+        final_message = final_completion.choices[0].message if final_completion.choices else None
+        tool_calls = getattr(final_message, "tool_calls", None) if final_message else None
+        self._emit_tool_notification_fallback(
+            tool_calls,
+            notified_tool_indices,
+            streams_arguments=streams_arguments,
+            model=model,
+        )
+
         return final_completion
 
     async def _openai_completion(

fast_agent/skills/registry.py

@@ -106,7 +106,6 @@ class SkillRegistry:
         errors: List[dict[str, str]] | None = None,
     ) -> List[SkillManifest]:
         manifests: List[SkillManifest] = []
-        cwd = Path.cwd()
         for entry in sorted(directory.iterdir()):
             if not entry.is_dir():
                 continue
@@ -115,13 +114,22 @@ class SkillRegistry:
                 continue
             manifest, error = cls._parse_manifest(manifest_path)
             if manifest:
-                relative_path: Path | None = None
-                for base in (cwd, directory):
-                    try:
-                        relative_path = manifest_path.relative_to(base)
-                        break
-                    except ValueError:
-                        continue
+                # Compute relative path from skills directory (not cwd)
+                # Old behavior: try both cwd and directory
+                # relative_path: Path | None = None
+                # for base in (cwd, directory):
+                #     try:
+                #         relative_path = manifest_path.relative_to(base)
+                #         break
+                #     except ValueError:
+                #         continue
+
+                # New behavior: always relative to skills directory
+                try:
+                    relative_path = manifest_path.relative_to(directory)
+                except ValueError:
+                    relative_path = None
+
                 manifest = replace(manifest, relative_path=relative_path)
                 manifests.append(manifest)
             elif errors is not None:
@@ -175,7 +183,7 @@ def format_skills_for_prompt(manifests: Sequence[SkillManifest]) -> str:
     preamble = (
         "Skills provide specialized capabilities and domain knowledge. Use a Skill if it seems in any way "
         "relevant to the Users task, intent or would increase effectiveness. \n"
-        "The 'execute' tool gives you shell access to the current working directory (agent workspace) "
+        "The 'execute' tool gives you direct shell access to the current working directory (agent workspace) "
         "and outputted files are visible to the User.\n"
         "To use a Skill you must first read the SKILL.md file (use 'execute' tool).\n "
         "Only use skills listed in <available_skills> below.\n\n"

fast_agent/tools/shell_runtime.py

@@ -42,13 +42,13 @@ class ShellRuntime:
 
             self._tool = Tool(
                 name="execute",
-                description=f"Run a shell command ({shell_name}) inside the agent workspace and return its output.",
+                description=f"Run a shell command directly in {shell_name}.",
                 inputSchema={
                     "type": "object",
                     "properties": {
                         "command": {
                             "type": "string",
-                            "description": "Shell command to execute (e.g. 'cat README.md').",
+                            "description": "Command string only - no shell executable prefix (correct: 'pwd', incorrect: 'bash -c pwd').",
                         }
                     },
                     "required": ["command"],
@@ -71,8 +71,8 @@ class ShellRuntime:
     def working_directory(self) -> Path:
         """Return the working directory used for shell execution."""
         # TODO -- reinstate when we provide duplication/isolation of skill workspaces
-        # if self._skills_directory and self._skills_directory.exists():
-        #     return self._skills_directory
+        if self._skills_directory and self._skills_directory.exists():
+            return self._skills_directory
         return Path.cwd()
 
     def runtime_info(self) -> Dict[str, str | None]: