fast-agent-mcp 0.2.17__py3-none-any.whl → 0.2.19__py3-none-any.whl

mcp_agent/executor/executor.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextvars
 import functools
 from abc import ABC, abstractmethod
 from contextlib import asynccontextmanager
@@ -206,13 +207,13 @@ class AsyncioExecutor(Executor):
                 else:
                     # Execute the callable and await if it returns a coroutine
                     loop = asyncio.get_running_loop()
-
+                    ctx = contextvars.copy_context()
                     # If kwargs are provided, wrap the function with partial
                     if kwargs:
                         wrapped_task = functools.partial(task, **kwargs)
-                        result = await loop.run_in_executor(None, wrapped_task)
+                        result = await loop.run_in_executor(None, lambda: ctx.run(wrapped_task))
                     else:
-                        result = await loop.run_in_executor(None, task)
+                        result = await loop.run_in_executor(None, lambda: ctx.run(task))
 
                     # Handle case where the sync function returns a coroutine
                     if asyncio.iscoroutine(result):
@@ -234,12 +235,10 @@ class AsyncioExecutor(Executor):
         *tasks: Callable[..., R] | Coroutine[Any, Any, R],
         **kwargs: Any,
     ) -> List[R | BaseException]:
-        # TODO: saqadri - validate if async with self.execution_context() is needed here
-        async with self.execution_context():
-            return await asyncio.gather(
-                *(self._execute_task(task, **kwargs) for task in tasks),
-                return_exceptions=True,
-            )
+        return await asyncio.gather(
+            *(self._execute_task(task, **kwargs) for task in tasks),
+            return_exceptions=True,
+        )
 
     async def execute_streaming(
         self,

mcp_agent/llm/augmented_llm.py

@@ -171,6 +171,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         # We never expect this for structured() calls - this is for interactive use - developers
         # can do this programatically
         # TODO -- create a "fast-agent" control role rather than magic strings
+
         if multipart_messages[-1].first_text().startswith("***SAVE_HISTORY"):
             parts: list[str] = multipart_messages[-1].first_text().split(" ", 1)
             filename: str = (
@@ -220,6 +221,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         request_params: RequestParams | None = None,
     ) -> Tuple[ModelT | None, PromptMessageMultipart]:
         """Return a structured response from the LLM using the provided messages."""
+
         self._precall(multipart_messages)
         result, assistant_response = await self._apply_prompt_provider_specific_structured(
             multipart_messages, model, request_params

mcp_agent/llm/providers/augmented_llm_anthropic.py

@@ -347,10 +347,11 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
     ) -> Tuple[ModelT | None, PromptMessageMultipart]:  # noqa: F821
         request_params = self.get_request_params(request_params)
 
+        # TODO - convert this to use Tool Calling convention for Anthropic Structured outputs
         multipart_messages[-1].add_text(
             """YOU MUST RESPOND IN THE FOLLOWING FORMAT:
             {schema}
-            RESPOND ONLY WITH THE JSON, NO PREAMBLE OR CODE FENCES """.format(
+            RESPOND ONLY WITH THE JSON, NO PREAMBLE, CODE FENCES OR 'properties' ARE PERMISSABLE """.format(
                 schema=model.model_json_schema()
             )
         )

mcp_agent/llm/providers/augmented_llm_deepseek.py

@@ -8,9 +8,7 @@ DEFAULT_DEEPSEEK_MODEL = "deepseekchat"  # current Deepseek only has two type mo
 
 class DeepSeekAugmentedLLM(OpenAIAugmentedLLM):
     def __init__(self, *args, **kwargs) -> None:
-        super().__init__(
-            *args, provider=Provider.DEEPSEEK, **kwargs
-        )  # Properly pass args and kwargs to parent
+        super().__init__(*args, provider=Provider.DEEPSEEK, **kwargs)
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize Deepseek-specific default parameters"""

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -222,7 +222,10 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                         method="tools/call",
                         params=CallToolRequestParams(
                             name=tool_call.function.name,
-                            arguments=from_json(tool_call.function.arguments, allow_partial=True),
+                            arguments={}
+                            if not tool_call.function.arguments
+                            or tool_call.function.arguments.strip() == ""
+                            else from_json(tool_call.function.arguments, allow_partial=True),
                         ),
                     )
                     result = await self.call_tool(tool_call_request, tool_call.id)

mcp_agent/mcp/mcp_aggregator.py

@@ -21,6 +21,7 @@ from mcp.types import (
     TextContent,
     Tool,
 )
+from opentelemetry import trace
 from pydantic import AnyUrl, BaseModel, ConfigDict
 
 from mcp_agent.context_dependent import ContextDependent
@@ -469,16 +470,20 @@ class MCPAggregator(ContextDependent):
             },
         )
 
-        return await self._execute_on_server(
-            server_name=server_name,
-            operation_type="tool",
-            operation_name=local_tool_name,
-            method_name="call_tool",
-            method_args={"name": local_tool_name, "arguments": arguments},
-            error_factory=lambda msg: CallToolResult(
-                isError=True, content=[TextContent(type="text", text=msg)]
-            ),
-        )
+        tracer = trace.get_tracer(__name__)
+        with tracer.start_as_current_span(f"MCP Tool: {server_name}/{local_tool_name}"):
+            trace.get_current_span().set_attribute("tool_name", local_tool_name)
+            trace.get_current_span().set_attribute("server_name", server_name)
+            return await self._execute_on_server(
+                server_name=server_name,
+                operation_type="tool",
+                operation_name=local_tool_name,
+                method_name="call_tool",
+                method_args={"name": local_tool_name, "arguments": arguments},
+                error_factory=lambda msg: CallToolResult(
+                    isError=True, content=[TextContent(type="text", text=msg)]
+                ),
+            )
 
     async def get_prompt(
         self,

mcp_agent/mcp/mcp_connection_manager.py

@@ -262,7 +262,7 @@ class MCPConnectionManager(ContextDependent):
             if config.transport == "stdio":
                 server_params = StdioServerParameters(
                     command=config.command,
-                    args=config.args,
+                    args=config.args if config.args is not None else [],
                     env={**get_default_environment(), **(config.env or {})},
                 )
                 # Create custom error handler to ensure all output is captured

mcp_agent/logging/tracing.py

@@ -1,138 +0,0 @@
-"""
-Telemetry manager that defines distributed tracing decorators for OpenTelemetry traces/spans
-for the Logger module for MCP Agent
-"""
-
-import asyncio
-import functools
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple
-
-from opentelemetry import trace
-from opentelemetry.context import Context as OtelContext
-from opentelemetry.propagate import extract as otel_extract
-from opentelemetry.trace import SpanKind, Status, StatusCode, set_span_in_context
-from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
-
-from mcp_agent.context_dependent import ContextDependent
-
-if TYPE_CHECKING:
-    from mcp_agent.context import Context
-
-
-class TelemetryManager(ContextDependent):
-    """
-    Simple manager for creating OpenTelemetry spans automatically.
-    Decorator usage: @telemetry.traced("SomeSpanName")
-    """
-
-    def __init__(self, context: Optional["Context"] = None, **kwargs) -> None:
-        # If needed, configure resources, exporters, etc.
-        # E.g.: from opentelemetry.sdk.trace import TracerProvider
-        # trace.set_tracer_provider(TracerProvider(...))
-        super().__init__(context=context, **kwargs)
-
-    def traced(
-        self,
-        name: str | None = None,
-        kind: SpanKind = SpanKind.INTERNAL,
-        attributes: Dict[str, Any] = None,
-    ) -> Callable:
-        """
-        Decorator that automatically creates and manages a span for a function.
-        Works for both async and sync functions.
-        """
-
-        def decorator(func):
-            span_name = name or f"{func.__module__}.{func.__qualname__}"
-
-            tracer = self.context.tracer or trace.get_tracer("mcp_agent")
-
-            @functools.wraps(func)
-            async def async_wrapper(*args, **kwargs):
-                with tracer.start_as_current_span(span_name, kind=kind) as span:
-                    if attributes:
-                        for k, v in attributes.items():
-                            span.set_attribute(k, v)
-                    # Record simple args
-                    self._record_args(span, args, kwargs)
-                    try:
-                        res = await func(*args, **kwargs)
-                        return res
-                    except Exception as e:
-                        span.record_exception(e)
-                        span.set_status(Status(StatusCode.ERROR))
-                        raise
-
-            @functools.wraps(func)
-            def sync_wrapper(*args, **kwargs):
-                with tracer.start_as_current_span(span_name, kind=kind) as span:
-                    if attributes:
-                        for k, v in attributes.items():
-                            span.set_attribute(k, v)
-                    # Record simple args
-                    self._record_args(span, args, kwargs)
-                    try:
-                        res = func(*args, **kwargs)
-                        return res
-                    except Exception as e:
-                        span.record_exception(e)
-                        span.set_status(Status(StatusCode.ERROR))
-                        raise
-
-            if asyncio.iscoroutinefunction(func):
-                return async_wrapper
-            else:
-                return sync_wrapper
-
-        return decorator
-
-    def _record_args(self, span, args, kwargs) -> None:
-        """Optionally record primitive args as span attributes."""
-        for i, arg in enumerate(args):
-            if isinstance(arg, (str, int, float, bool)):
-                span.set_attribute(f"arg_{i}", str(arg))
-        for k, v in kwargs.items():
-            if isinstance(v, (str, int, float, bool)):
-                span.set_attribute(k, str(v))
-
-
-class MCPRequestTrace:
-    """Helper class for trace context propagation in MCP"""
-
-    @staticmethod
-    def start_span_from_mcp_request(
-        method: str, params: Dict[str, Any]
-    ) -> Tuple[trace.Span, OtelContext]:
-        """Extract trace context from incoming MCP request and start a new span"""
-        # Extract trace context from _meta if present
-        carrier = {}
-        _meta = params.get("_meta", {})
-        if "traceparent" in _meta:
-            carrier["traceparent"] = _meta["traceparent"]
-        if "tracestate" in _meta:
-            carrier["tracestate"] = _meta["tracestate"]
-
-        # Extract context and start span
-        ctx = otel_extract(carrier, context=OtelContext())
-        tracer = trace.get_tracer(__name__)
-        span = tracer.start_span(method, context=ctx, kind=SpanKind.SERVER)
-        return span, set_span_in_context(span)
-
-    @staticmethod
-    def inject_trace_context(arguments: Dict[str, Any]) -> Dict[str, Any]:
-        """Inject current trace context into outgoing MCP request arguments"""
-        carrier = {}
-        TraceContextTextMapPropagator().inject(carrier)
-
-        # Create or update _meta with trace context
-        _meta = arguments.get("_meta", {})
-        if "traceparent" in carrier:
-            _meta["traceparent"] = carrier["traceparent"]
-        if "tracestate" in carrier:
-            _meta["tracestate"] = carrier["tracestate"]
-        arguments["_meta"] = _meta
-
-        return arguments
-
-
-telemetry = TelemetryManager()