Simplify Agents GitHub and Code agents, bring pydantic bridge into repo

Author: strawgate

.github/workflows/publish-to-pypi.yml

@@ -20,8 +20,7 @@ jobs:
       - id: set-matrix
         run: echo "projects=$(find . -name "pyproject.toml" -not -path "*/.venv/*" -exec dirname {} \; | jq -R -s -c 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
 
-  test:
-    name: Run Tests
+  publish:
     continue-on-error: true
     runs-on: ubuntu-latest
     needs: [list-projects]
@@ -32,6 +31,9 @@ jobs:
       fail-fast: false 
       matrix: 
         pyproject: ${{fromJson(needs.list-projects.outputs.projects)}}
+
+    name: ${{ matrix.pyproject }} - Publish to PyPI
+
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -54,6 +56,7 @@ jobs:
         working-directory: ${{ matrix.pyproject }}
         env:
           GEMINI_API_KEY: ${{ secrets.GOOGLE_API_KEY }}
+          GITHUB_PERSONAL_ACCESS_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           MODEL: ${{ vars.MODEL }}
 
       - name: Clean

fastmcp-agents-library/agents/fastmcp-agents-library-agent-github/.vscode/launch.json renamed to fastmcp-agents-bridge/fastmcp_agents_bridge_pydantic_ai/.vscode/launch.json

@@ -4,6 +4,13 @@
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
+        {
+            "name": "Python Debugger: Current File",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal"
+        },
         // Debug Tests config
         {
             "name": "Python: Debug Tests",
@@ -20,13 +27,5 @@
             "console": "integratedTerminal",
             "justMyCode": false
         },
-
-        {
-            "name": "Python Debugger: Current File",
-            "type": "debugpy",
-            "request": "launch",
-            "program": "${file}",
-            "console": "integratedTerminal"
-        }
     ]
 }

fastmcp-agents-library/agents/fastmcp-agents-library-agent-simple-code/.vscode/settings.json renamed to fastmcp-agents-bridge/fastmcp_agents_bridge_pydantic_ai/.vscode/settings.json

@@ -4,5 +4,5 @@
     ],
     "python.testing.unittestEnabled": false,
     "python.testing.pytestEnabled": true,
-    "python-envs.pythonProjects": []
+    "python.venvPath": "/Users/bill.easton/repos/fastmcp-ai-agent-bridge"
 }

fastmcp-agents-library/agents/fastmcp-agents-library-agent-github/README.md renamed to fastmcp-agents-bridge/fastmcp_agents_bridge_pydantic_ai/README.md

@@ -0,0 +1,64 @@
+from typing import TYPE_CHECKING, Any
+
+import logfire
+from fastmcp import FastMCP
+from fastmcp.mcp_config import MCPConfig, TransformingStdioMCPServer
+from pydantic import BaseModel
+from pydantic_ai import Agent
+from pydantic_ai.models.google import GoogleModel
+from pydantic_ai.providers.google import GoogleProvider
+from pydantic_ai.settings import ModelSettings
+
+from fastmcp_agents.bridge.pydantic_ai.toolset import FastMCPToolset
+
+if TYPE_CHECKING:
+    from pydantic_ai.agent import AgentRunResult
+
+Agent.instrument_all()
+
+logfire_config = logfire.configure(console=logfire.ConsoleOptions(min_log_level="info"), send_to_logfire=False)
+
+model = GoogleModel("gemini-2.5-flash", provider=GoogleProvider(vertexai=True), settings=ModelSettings())
+
+mcp_config = MCPConfig(
+    mcpServers={
+        "echo": TransformingStdioMCPServer(
+            command="uvx",
+            args=["mcp-server-time"],
+            tools={},
+        ),
+    },
+)
+
+fastmcp_toolset: FastMCPToolset[None] = FastMCPToolset[None].from_mcp_config(mcp_config)
+
+agent = Agent(
+    "model",
+    system_prompt="Be concise, reply with one sentence.",
+    toolsets=[fastmcp_toolset],
+)
+
+
+class ConvertTimezonesResponse(BaseModel):
+    provided_time: str
+    converted_time: str
+    starting_timezone: str
+    ending_timezone: str
+
+
+proxy: FastMCP[Any] = FastMCP[Any](name="time_zone")
+
+
+@proxy.tool(name="convert_timezones")
+async def convert_timezones(time: str, from_timezone: str, to_timezone: str) -> ConvertTimezonesResponse:
+    """Convert a time from one timezone to another"""
+
+    result: AgentRunResult[ConvertTimezonesResponse] = await agent.run(
+        f"Convert {time} from {from_timezone} to {to_timezone}", output_type=ConvertTimezonesResponse
+    )
+
+    return result.output
+
+
+if __name__ == "__main__":
+    proxy.run(transport="sse")

fastmcp-agents-bridge/fastmcp_agents_bridge_pydantic_ai/examples/time_zone.py

@@ -0,0 +1,40 @@
+[project]
+name = "fastmcp-agents-bridge-pydantic-ai"
+version = "0.1.4"
+description = "Pydantic AI Agent Bridge"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "fastmcp",
+    "logfire>=3.25.0",
+    "pydantic-ai>=0.4.4",
+]
+
+[dependency-groups]
+dev = [
+  "pytest",
+  "pytest-mock",
+  "pytest-asyncio",
+  "ruff",
+  "basedpyright>=1.30.1",
+]
+
+lint = [
+  "ruff"
+]
+
+[build-system]
+requires = ["uv_build>=0.8.2,<0.9.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "fastmcp_agents.bridge.pydantic_ai"
+
+[tool.uv.sources]
+fastmcp = { git = "https://github.com/jlowin/fastmcp" }
+
+[tool.ruff]
+extend="../../pyproject.toml"
+
+[tool.pyright]
+extends = "../../pyproject.toml"

fastmcp-agents-bridge/fastmcp_agents_bridge_pydantic_ai/pyproject.toml

@@ -0,0 +1,3 @@
+from .toolset import FastMCPToolset
+
+__all__ = ["FastMCPToolset"]

fastmcp-agents-bridge/fastmcp_agents_bridge_pydantic_ai/src/fastmcp_agents/bridge/pydantic_ai/__init__.py

@@ -1,10 +1,12 @@
 import json
 from datetime import UTC, datetime
+from typing import Any
 
 import logfire
 from logfire import ConsoleOptions
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor
+
 from pydantic_ai import Agent
 
 
@@ -18,7 +20,7 @@ def get_tool_names_from_span(span: ReadableSpan) -> list[str]:
     if not isinstance(model_request_parameters, str):
         return []
 
-    deserialized_model_request_parameters = json.loads(model_request_parameters)
+    deserialized_model_request_parameters: dict[str, Any] = json.loads(model_request_parameters)
 
     if not (function_tools := deserialized_model_request_parameters.get("function_tools")):
         return []
@@ -64,6 +66,7 @@ def get_picked_tools_from_span(span: ReadableSpan) -> list[str]:
 
 def format_span(span: ReadableSpan) -> str:
     timestamp: datetime | None = datetime.fromtimestamp(span.start_time / 1_000_000_000, tz=UTC) if span.start_time else None
+    model_name: str | None
 
     span_message = span.name
 
@@ -78,15 +81,15 @@ def format_span(span: ReadableSpan) -> str:
 
     match span.name:
         case "running tool":
-            model_name: str | None = str(span.attributes.get("gen_ai.request.model"))
+            model_name = str(span.attributes.get("gen_ai.request.model"))
             tool_name: str | None = str(span.attributes.get("gen_ai.tool.name"))
             tool_arguments: str | None = str(span.attributes.get("tool_arguments"))
             tool_response: str | None = str(span.attributes.get("tool_response"))
 
             span_message = f"Model called {tool_name} with arguments: {tool_arguments} returned: {tool_response[:200]}"
 
         case _ if span.name.startswith("chat "):
-            model_name: str | None = str(span.attributes.get("gen_ai.request.model"))
+            model_name = str(span.attributes.get("gen_ai.request.model"))
             # tool_names: list[str] = get_tool_names_from_span(span)
             picked_tools: list[str] = get_picked_tools_from_span(span)
             span_message = f"Model: {model_name} -- Picked tools: {picked_tools}"

fastmcp-agents-library/agents/fastmcp-agents-library-agent-github/src/fastmcp_agents/library/agent/github/shared/logging.py renamed to fastmcp-agents-bridge/fastmcp_agents_bridge_pydantic_ai/src/fastmcp_agents/bridge/pydantic_ai/logging.py

@@ -0,0 +1,25 @@
+from typing import Any, Self
+
+from fastmcp.tools import FunctionTool
+from pydantic import BaseModel
+from pydantic.type_adapter import TypeAdapter
+
+from pydantic_ai.agent import Agent, AgentRunResult
+
+
+class AgentTool[InputModel: BaseModel, OutputModel: BaseModel](FunctionTool):
+    @classmethod
+    def from_agent(cls, agent: Agent[Any, OutputModel], input_model: type[InputModel], name: str, description: str, prompt: str) -> Self:
+        async def invoke_agent(input_model: InputModel) -> OutputModel:
+            task = prompt.format(input_model=input_model, **input_model.model_dump())
+
+            result: AgentRunResult[OutputModel] = await agent.run(task)
+            return result.output
+
+        return cls(
+            name=name,
+            fn=invoke_agent,
+            description=description,
+            parameters=input_model.model_json_schema(),
+            output_schema=TypeAdapter(agent.output_type).json_schema(),
+        )

fastmcp-agents-bridge/fastmcp_agents_bridge_pydantic_ai/src/fastmcp_agents/bridge/pydantic_ai/tool.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import base64
+import contextlib
+from typing import TYPE_CHECKING, Any, ClassVar, override
+
+import pydantic_core
+from fastmcp import FastMCP  # noqa: TC002
+from fastmcp.exceptions import ToolError
+from fastmcp.mcp_config import MCPConfig
+from fastmcp.utilities.mcp_config import composite_server_from_mcp_config  # pyright: ignore[reportUnknownVariableType]
+from mcp.types import AudioContent, ContentBlock, EmbeddedResource, ImageContent, TextContent, TextResourceContents
+from pydantic import BaseModel, ConfigDict, Field
+
+from pydantic_ai.exceptions import ModelRetry
+from pydantic_ai.mcp import TOOL_SCHEMA_VALIDATOR, messages
+from pydantic_ai.tools import AgentDepsT, ToolDefinition
+from pydantic_ai.toolsets import AbstractToolset
+from pydantic_ai.toolsets.abstract import ToolsetTool
+
+if TYPE_CHECKING:
+    from fastmcp.mcp_config import MCPServerTypes
+    from fastmcp.tools import Tool as FastMCPTool
+    from fastmcp.tools.tool import ToolResult
+    from fastmcp.tools.tool_transform import ToolTransformConfig
+
+    from pydantic_ai.tools import RunContext
+
+
+FastMCPToolResult = messages.BinaryContent | dict[str, Any] | str | None
+
+FastMCPToolResults = list[FastMCPToolResult] | FastMCPToolResult
+
+
+class FastMCPToolset(BaseModel, AbstractToolset[AgentDepsT]):  # pyright: ignore[reportUnsafeMultipleInheritance]
+    model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True)
+    fastmcp: FastMCP[Any] = Field(..., description="The fastmcp instance to bridge to")
+    tool_retries: int = Field(default=2, description="The number of times to retry a failed tool call")
+
+    @override
+    async def get_tools(self, ctx: RunContext[AgentDepsT]) -> dict[str, ToolsetTool[AgentDepsT]]:
+        fastmcp_tools: dict[str, FastMCPTool] = await self.fastmcp.get_tools()
+
+        return {
+            tool.name: convert_fastmcp_tool_to_toolset_tool(toolset=self, fastmcp_tool=tool, retries=self.tool_retries)
+            for tool in fastmcp_tools.values()
+        }
+
+    async def get_tool(self, key: str, transformation: ToolTransformConfig | None = None) -> ToolsetTool[AgentDepsT]:
+        fastmcp_tool: FastMCPTool = await self.fastmcp.get_tool(key=key)
+
+        if transformation:
+            fastmcp_tool = transformation.apply(fastmcp_tool)
+
+        return convert_fastmcp_tool_to_toolset_tool(toolset=self, fastmcp_tool=fastmcp_tool, retries=self.tool_retries)
+
+    def add_tool_transformation(self, tool_name: str, transformation: ToolTransformConfig) -> None:
+        self.fastmcp.add_tool_transformation(tool_name=tool_name, transformation=transformation)
+
+    def remove_tool_transformation(self, tool_name: str) -> None:
+        self.fastmcp.remove_tool_transformation(tool_name=tool_name)
+
+    @override
+    async def call_tool(self, name: str, tool_args: dict[str, Any], ctx: RunContext[AgentDepsT], tool: ToolsetTool[AgentDepsT]) -> Any:  # pyright: ignore[reportAny]
+        fastmcp_tool: FastMCPTool = await self.fastmcp.get_tool(key=name)
+        try:
+            call_tool_result: ToolResult = await fastmcp_tool.run(arguments=tool_args)
+        except ToolError as e:
+            raise ModelRetry(message=str(object=e)) from e
+        return call_tool_result.structured_content or _map_fastmcp_tool_results(parts=call_tool_result.content)
+
+    async def call_tool_direct(self, name: str, tool_args: dict[str, Any]) -> Any:  # pyright: ignore[reportAny]
+        fastmcp_tool: FastMCPTool = await self.fastmcp.get_tool(key=name)
+        try:
+            call_tool_result: ToolResult = await fastmcp_tool.run(arguments=tool_args)
+        except ToolError as e:
+            raise ModelRetry(message=str(object=e)) from e
+        return call_tool_result.structured_content or _map_fastmcp_tool_results(parts=call_tool_result.content)
+
+    @classmethod
+    def from_mcp_config(cls, mcp_config: MCPConfig | dict[str, MCPServerTypes] | dict[str, Any]) -> FastMCPToolset[AgentDepsT]:
+        if not isinstance(mcp_config, MCPConfig):
+            mcp_config = MCPConfig(mcpServers=mcp_config)
+
+        mcp_server_host: FastMCP[Any] = composite_server_from_mcp_config(config=mcp_config, name_as_prefix=False)
+
+        return cls(fastmcp=mcp_server_host)
+
+    @classmethod
+    def from_mcp_server(cls, name: str, mcp_server: MCPServerTypes) -> FastMCPToolset[AgentDepsT]:
+        mcp_config = MCPConfig(mcpServers={name: mcp_server})
+        return cls.from_mcp_config(mcp_config=mcp_config)
+
+
+def convert_fastmcp_tool_to_toolset_tool(
+    toolset: FastMCPToolset[AgentDepsT], fastmcp_tool: FastMCPTool, retries: int
+) -> ToolsetTool[AgentDepsT]:
+    return ToolsetTool[AgentDepsT](
+        tool_def=ToolDefinition(
+            name=fastmcp_tool.name,
+            description=fastmcp_tool.description,
+            parameters_json_schema=fastmcp_tool.parameters,
+        ),
+        toolset=toolset,
+        max_retries=retries,
+        args_validator=TOOL_SCHEMA_VALIDATOR,
+    )
+
+
+def _map_fastmcp_tool_results(parts: list[ContentBlock]) -> list[FastMCPToolResult]:
+    return [_map_fastmcp_tool_result(part) for part in parts]
+
+
+def _map_fastmcp_tool_result(part: ContentBlock) -> FastMCPToolResult:
+    if isinstance(part, TextContent):
+        text = part.text
+        if text.startswith(("[", "{")):
+            with contextlib.suppress(ValueError):
+                result: Any = pydantic_core.from_json(text)  # pyright: ignore[reportAny]
+                if isinstance(result, dict | list):
+                    return result  # pyright: ignore[reportUnknownVariableType, reportReturnType]
+        return text
+
+    if isinstance(part, ImageContent):
+        return messages.BinaryContent(data=base64.b64decode(part.data), media_type=part.mimeType)
+
+    if isinstance(part, AudioContent):
+        return messages.BinaryContent(data=base64.b64decode(part.data), media_type=part.mimeType)
+
+    if isinstance(part, EmbeddedResource):
+        resource = part.resource
+        if isinstance(resource, TextResourceContents):
+            return resource.text
+
+        # BlobResourceContents
+        return messages.BinaryContent(
+            data=base64.b64decode(resource.blob),
+            media_type=resource.mimeType or "application/octet-stream",
+        )
+
+    msg = f"Unsupported/Unknown content block type: {type(part)}"
+    raise ValueError(msg)