casual-mcp 0.1.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

casual_mcp/__init__.py

@@ -1,13 +1,12 @@
 from . import models
 from .mcp_tool_chat import McpToolChat
-from .multi_server_mcp_client import MultiServerMCPClient
 from .providers.provider_factory import ProviderFactory
-from .utils import load_config
+from .utils import load_config, load_mcp_client
 
 __all__ = [
     "McpToolChat",
-    "MultiServerMCPClient",
     "ProviderFactory",
     "load_config",
+    "load_mcp_client",
     "models",
 ]

casual_mcp/cli.py

@@ -3,6 +3,7 @@ import uvicorn
 from rich.console import Console
 from rich.table import Table
 
+from casual_mcp.models.mcp_server_config import RemoteServerConfig
 from casual_mcp.utils import load_config
 
 app = typer.Typer()
@@ -26,23 +27,22 @@ def servers():
     """
     Return a table of all configured servers
     """
-    config = load_config('config.json')
-    table = Table("Name", "Type", "Path / Package / Url", "Env")
+    config = load_config('casual_mcp_config.json')
+    table = Table("Name", "Type", "Command / Url", "Env")
 
     for name, server in config.servers.items():
+        type = 'local'
+        if isinstance(server, RemoteServerConfig):
+            type = 'remote'
+
         path = ''
-        match server.type:
-            case 'python':
-                path = server.path
-            case 'node':
-                path = server.path
-            case 'http':
-                path = server.url
-            case 'uvx':
-                path = server.package
+        if isinstance(server, RemoteServerConfig):
+            path = server.url
+        else:
+            path = f"{server.command} {" ".join(server.args)}"
         env = ''
 
-        table.add_row(name, server.type, path, env)
+        table.add_row(name, type, path, env)
 
     console.print(table)
 
@@ -51,7 +51,7 @@ def models():
     """
     Return a table of all configured models
     """
-    config = load_config('config.json')
+    config = load_config('casual_mcp_config.json')
     table = Table("Name", "Provider", "Model", "Endpoint")
 
     for name, model in config.models.items():

casual_mcp/main.py

@@ -6,16 +6,16 @@ from dotenv import load_dotenv
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel, Field
 
-from casual_mcp import McpToolChat, MultiServerMCPClient
+from casual_mcp import McpToolChat
 from casual_mcp.logging import configure_logging, get_logger
-from casual_mcp.models.messages import CasualMcpMessage
+from casual_mcp.models.messages import ChatMessage
 from casual_mcp.providers.provider_factory import ProviderFactory
-from casual_mcp.utils import load_config, render_system_prompt
+from casual_mcp.utils import load_config, load_mcp_client, render_system_prompt
 
 load_dotenv()
-config = load_config("config.json")
-mcp_client = MultiServerMCPClient(namespace_tools=config.namespace_tools)
-provider_factory = ProviderFactory()
+config = load_config("casual_mcp_config.json")
+mcp_client = load_mcp_client(config)
+provider_factory = ProviderFactory(mcp_client)
 
 app = FastAPI()
 
@@ -45,7 +45,7 @@ class GenerateRequest(BaseModel):
     user_prompt: str = Field(
         title="User Prompt"
     )
-    messages: list[CasualMcpMessage] | None = Field(
+    messages: list[ChatMessage] | None = Field(
         default=None, title="Previous messages to supply to the LLM"
     )
 
@@ -59,19 +59,20 @@ async def perform_chat(
     model,
     user,
     system: str | None = None,
-    messages: list[CasualMcpMessage] = None,
+    messages: list[ChatMessage] = None,
     session_id: str | None = None
-) -> list[CasualMcpMessage]:
+) -> list[ChatMessage]:
     # Get Provider from Model Config
     model_config = config.models[model]
-    provider = provider_factory.get_provider(model, model_config)
+    provider = await provider_factory.get_provider(model, model_config)
 
     if not system:
         if (model_config.template):
-            system = render_system_prompt(
-                f"{model_config.template}.j2",
-                await mcp_client.list_tools()
-            )
+            async with mcp_client:
+                system = render_system_prompt(
+                    f"{model_config.template}.j2",
+                    await mcp_client.list_tools()
+                )
         else:
             system = default_system_prompt
 
@@ -85,10 +86,6 @@ async def perform_chat(
 
 @app.post("/chat")
 async def chat(req: GenerateRequest):
-    if len(mcp_client.tools) == 0:
-        await mcp_client.load_config(config.servers)
-        provider_factory.set_tools(await mcp_client.list_tools())
-
     messages = await perform_chat(
         req.model,
         system=req.system_prompt,

casual_mcp/mcp_tool_chat.py

@@ -1,30 +1,40 @@
+import json
+import os
+
+from fastmcp import Client
 
 from casual_mcp.logging import get_logger
-from casual_mcp.models.messages import CasualMcpMessage, SystemMessage, UserMessage
-from casual_mcp.multi_server_mcp_client import MultiServerMCPClient
+from casual_mcp.models.messages import (
+    ChatMessage,
+    SystemMessage,
+    ToolResultMessage,
+    UserMessage,
+)
+from casual_mcp.models.tool_call import AssistantToolCall
 from casual_mcp.providers.provider_factory import LLMProvider
+from casual_mcp.utils import format_tool_call_result
 
 logger = get_logger("mcp_tool_chat")
-sessions: dict[str, list[CasualMcpMessage]] = {}
+sessions: dict[str, list[ChatMessage]] = {}
 
 
 class McpToolChat:
-    def __init__(self, tool_client: MultiServerMCPClient, provider: LLMProvider, system: str):
+    def __init__(self, mcp_client: Client, provider: LLMProvider, system: str):
         self.provider = provider
-        self.tool_client = tool_client
+        self.mcp_client = mcp_client
         self.system = system
 
     @staticmethod
-    def get_session(session_id) -> list[CasualMcpMessage] | None:
+    def get_session(session_id) -> list[ChatMessage] | None:
         global sessions
         return sessions.get(session_id)
 
     async def chat(
         self,
         prompt: str | None = None,
-        messages: list[CasualMcpMessage] = None,
+        messages: list[ChatMessage] = None,
         session_id: str | None = None
-    ) -> list[CasualMcpMessage]:
+    ) -> list[ChatMessage]:
         global sessions
 
         # todo: check that we have a prompt or that there is a user message in messages
@@ -41,7 +51,8 @@ class McpToolChat:
             messages = sessions[session_id].copy()
 
         logger.info("Start Chat")
-        tools = await self.tool_client.list_tools()
+        async with self.mcp_client:
+            tools = await self.mcp_client.list_tools()
 
         if messages is None or len(messages) == 0:
             message_history = []
@@ -69,7 +80,7 @@ class McpToolChat:
                 result_count = 0
                 for tool_call in ai_message.tool_calls:
                     try:
-                        result = await self.tool_client.execute(tool_call)
+                        result = await self.execute(tool_call)
                     except Exception as e:
                         logger.error(e)
                         return messages
@@ -88,3 +99,32 @@ class McpToolChat:
 
         return new_messages
 
+
+    async def execute(self, tool_call: AssistantToolCall):
+        tool_name = tool_call.function.name
+        tool_args = json.loads(tool_call.function.arguments)
+        try:
+            async with self.mcp_client:
+                result = await self.mcp_client.call_tool(tool_name, tool_args)
+        except Exception as e:
+            if isinstance(e, ValueError):
+                logger.warning(e)
+            else:
+                logger.error(f"Error calling tool: {e}")
+
+            return ToolResultMessage(
+                name=tool_call.function.name,
+                tool_call_id=tool_call.id,
+                content=str(e),
+            )
+
+        logger.debug(f"Tool Call Result: {result}")
+
+        result_format = os.getenv('TOOL_RESULT_FORMAT', 'result')
+        content = format_tool_call_result(tool_call, result[0].text, style=result_format)
+
+        return ToolResultMessage(
+            name=tool_call.function.name,
+            tool_call_id=tool_call.id,
+            content=content,
+        )

casual_mcp/models/__init__.py

@@ -1,13 +1,11 @@
 from .mcp_server_config import (
-    HttpMcpServerConfig,
     McpServerConfig,
-    NodeMcpServerConfig,
-    PythonMcpServerConfig,
-    UvxMcpServerConfig,
+    RemoteServerConfig,
+    StdioServerConfig,
 )
 from .messages import (
     AssistantMessage,
-    CasualMcpMessage,
+    ChatMessage,
     SystemMessage,
     ToolResultMessage,
     UserMessage,
@@ -22,12 +20,10 @@ __all__ = [
     "AssistantMessage",
     "ToolResultMessage",
     "SystemMessage",
-    "CasualMcpMessage",
+    "ChatMessage",
     "ModelConfig",
     "OpenAIModelConfig",
     "McpServerConfig",
-    "PythonMcpServerConfig",
-    "UvxMcpServerConfig",
-    "NodeMcpServerConfig",
-    "HttpMcpServerConfig",
+    "StdioServerConfig",
+    "RemoteServerConfig",
 ]

casual_mcp/models/mcp_server_config.py

@@ -1,39 +1,20 @@
-from typing import Literal
+from typing import Any, Literal
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
-class BaseMcpServerConfig(BaseModel):
-    type: Literal["python", "node", "http", "uvx"]
-    system_prompt: str | None | None = None
+class StdioServerConfig(BaseModel):
+    command: str
+    args: list[str] = Field(default_factory=list)
+    env: dict[str, Any] = Field(default_factory=dict)
+    cwd: str | None = None
+    transport: Literal["stdio"] = "stdio"
 
 
-class PythonMcpServerConfig(BaseMcpServerConfig):
-    type: Literal["python"] = "python"
-    path: str
-    env: dict[str, str] | None | None = None
-
-
-class UvxMcpServerConfig(BaseMcpServerConfig):
-    type: Literal["uvx"] = "uvx"
-    package: str
-    env: dict[str, str] | None | None = None
-
-
-class NodeMcpServerConfig(BaseMcpServerConfig):
-    type: Literal["node"] = "node"
-    path: str
-    env: dict[str, str] | None | None = None
-
-
-class HttpMcpServerConfig(BaseMcpServerConfig):
-    type: Literal["http"] = "http"
+class RemoteServerConfig(BaseModel):
     url: str
+    headers: dict[str, str] = Field(default_factory=dict)
+    transport: Literal["streamable-http", "sse", "http"] | None = None
 
 
-McpServerConfig = (
-    PythonMcpServerConfig
-    | NodeMcpServerConfig
-    | HttpMcpServerConfig
-    | UvxMcpServerConfig
-)
+McpServerConfig = StdioServerConfig | RemoteServerConfig

casual_mcp/models/messages.py

@@ -28,4 +28,4 @@ class UserMessage(BaseModel):
     content: str | None
 
 
-CasualMcpMessage: TypeAlias = AssistantMessage | SystemMessage | ToolResultMessage | UserMessage
+ChatMessage: TypeAlias = AssistantMessage | SystemMessage | ToolResultMessage | UserMessage

casual_mcp/providers/abstract_provider.py

@@ -2,14 +2,14 @@ from abc import ABC, abstractmethod
 
 import mcp
 
-from casual_mcp.models.messages import CasualMcpMessage
+from casual_mcp.models.messages import ChatMessage
 
 
 class CasualMcpProvider(ABC):
     @abstractmethod
     async def generate(
         self,
-        messages: list[CasualMcpMessage],
+        messages: list[ChatMessage],
         tools: list[mcp.Tool]
-    ) -> CasualMcpMessage:
+    ) -> ChatMessage:
         pass

casual_mcp/providers/ollama_provider.py

@@ -6,7 +6,7 @@ from ollama import ChatResponse, Client, ResponseError
 
 from casual_mcp.logging import get_logger
 from casual_mcp.models.generation_error import GenerationError
-from casual_mcp.models.messages import AssistantMessage, CasualMcpMessage
+from casual_mcp.models.messages import AssistantMessage, ChatMessage
 from casual_mcp.providers.abstract_provider import CasualMcpProvider
 
 logger = get_logger("providers.ollama")
@@ -15,7 +15,7 @@ def convert_tools(mcp_tools: list[mcp.Tool]) -> list[ollama.Tool]:
     raise Exception({"message": "under development"})
 
 
-def convert_messages(messages: list[CasualMcpMessage]) -> list[ollama.Message]:
+def convert_messages(messages: list[ChatMessage]) -> list[ollama.Message]:
     raise Exception({"message": "under development"})
 
 
@@ -32,9 +32,9 @@ class OllamaProvider(CasualMcpProvider):
 
     async def generate(
         self,
-        messages: list[CasualMcpMessage],
+        messages: list[ChatMessage],
         tools: list[mcp.Tool]
-    ) -> CasualMcpMessage:
+    ) -> ChatMessage:
         logger.info("Start Generating")
         logger.debug(f"Model: {self.model}")
 

casual_mcp/providers/openai_provider.py

@@ -15,7 +15,7 @@ from openai.types.chat import (
 
 from casual_mcp.logging import get_logger
 from casual_mcp.models.generation_error import GenerationError
-from casual_mcp.models.messages import AssistantMessage, CasualMcpMessage
+from casual_mcp.models.messages import AssistantMessage, ChatMessage
 from casual_mcp.models.tool_call import AssistantToolCall, AssistantToolCallFunction
 from casual_mcp.providers.abstract_provider import CasualMcpProvider
 
@@ -59,7 +59,7 @@ def convert_tool(mcp_tool: mcp.Tool) -> ChatCompletionToolParam | None:
     return ChatCompletionToolParam(**tool)
 
 
-def convert_messages(messages: list[CasualMcpMessage]) -> list[ChatCompletionMessageParam]:
+def convert_messages(messages: list[ChatMessage]) -> list[ChatCompletionMessageParam]:
     if not messages:
         return messages
 
@@ -144,7 +144,7 @@ class OpenAiProvider(CasualMcpProvider):
 
     async def generate(
         self,
-        messages: list[CasualMcpMessage],
+        messages: list[ChatMessage],
         tools: list[mcp.Tool]
     ) -> AssistantMessage:
         logger.info("Start Generating")

casual_mcp/providers/provider_factory.py

@@ -2,6 +2,7 @@ import os
 from typing import TypeAlias
 
 import mcp
+from fastmcp import Client
 
 from casual_mcp.logging import get_logger
 from casual_mcp.models.model_config import ModelConfig
@@ -13,15 +14,22 @@ logger = get_logger("providers.factory")
 LLMProvider: TypeAlias = OpenAiProvider | OllamaProvider
 
 class ProviderFactory:
-    def __init__(self):
-        self.providers: dict[str, LLMProvider] = {}
+    providers: dict[str, LLMProvider] = {}
+    tools: list[mcp.Tool] = None
+
+    def __init__(self, mcp_client: Client):
+        self.mcp_client = mcp_client
 
 
     def set_tools(self, tools: list[mcp.Tool]):
         self.tools = tools
 
 
-    def get_provider(self, name: str, config: ModelConfig) -> LLMProvider:
+    async def get_provider(self, name: str, config: ModelConfig) -> LLMProvider:
+        if not self.tools:
+            async with self.mcp_client:
+                self.tools = await self.mcp_client.list_tools()
+
         if self.providers.get(name):
             return self.providers.get(name)
 

casual_mcp/utils.py

@@ -2,6 +2,7 @@ import json
 from pathlib import Path
 
 import mcp
+from fastmcp import Client
 from jinja2 import Environment, FileSystemLoader
 from pydantic import ValidationError
 
@@ -9,6 +10,14 @@ from casual_mcp.models.config import Config
 from casual_mcp.models.tool_call import AssistantToolCall
 
 
+def load_mcp_client(config: Config) -> Client:
+    servers = {
+        key: value.model_dump()
+        for key, value in config.servers.items()
+    }
+    return Client(servers)
+
+
 def load_config(path: str | Path) -> Config:
     path = Path(path)
 

{casual_mcp-0.1.0.dist-info → casual_mcp-0.2.2.dist-info}/METADATA

@@ -1,16 +1,18 @@
 Metadata-Version: 2.4
 Name: casual-mcp
-Version: 0.1.0
+Version: 0.2.2
 Summary: Multi-server MCP client for LLM tool orchestration
 Author: Alex Stansfield
 License: MIT
+Project-URL: Homepage, https://github.com/AlexStansfield/casual-mcp
+Project-URL: Repository, https://github.com/AlexStansfield/casual-mcp
+Project-URL: Issue Tracker, https://github.com/AlexStansfield/casual-mcp/issues
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: amadeus>=12.0.0
 Requires-Dist: dateparser>=1.2.1
 Requires-Dist: fastapi>=0.115.12
-Requires-Dist: fastmcp>=2.3.4
+Requires-Dist: fastmcp>=2.5.1
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: ollama>=0.4.8
 Requires-Dist: openai>=1.78.0
@@ -98,11 +100,11 @@ Here is a list of functions in JSON format that you can invoke:
 ]
 ```
 
-## ⚙️ Configuration File (`config.json`)
+## ⚙️ Configuration File (`casual_mcp_config.json`)
 
 📄 See the [Programmatic Usage](#-programmatic-usage) section to build configs and messages with typed models.
 
-The CLI and API can be configured using a `config.json` file that defines:
+The CLI and API can be configured using a `casual_mcp_config.json` file that defines:
 
 - 🔧 Available **models** and their providers
 - 🧰 Available **MCP tool servers**
@@ -112,7 +114,6 @@ The CLI and API can be configured using a `config.json` file that defines:
 
 ```json
 {
-  "namespaced_tools": false,
   "models": {
     "lm-qwen-3": {
       "provider": "openai",
@@ -127,11 +128,10 @@ The CLI and API can be configured using a `config.json` file that defines:
   },
   "servers": {
     "time": {
-      "type": "python",
-      "path": "mcp-servers/time/server.py"
+      "command": "python",
+      "args": ["mcp-servers/time/server.py"]
     },
     "weather": {
-      "type": "http",
       "url": "http://localhost:5050/mcp"
     }
   }
@@ -142,25 +142,31 @@ The CLI and API can be configured using a `config.json` file that defines:
 
 Each model has:
 
-- `provider`: `"openai"` or `"ollama"`
+- `provider`: `"openai"` (more to come)
 - `model`: the model name (e.g., `gpt-4.1`, `qwen3-8b`)
 - `endpoint`: required for custom OpenAI-compatible backends (e.g., LM Studio)
 - `template`: optional name used to apply model-specific tool calling formatting
 
 ### 🔹 `servers`
 
-Each server has:
+Servers can either be local (over stdio) or remote.
 
-- `type`: `"python"`, `"http"`, `"node"`, or `"uvx"`
-- For `python`/`node`: `path` to the script
-- For `http`: `url` to the remote MCP endpoint
-- For `uvx`: `package` for the package to run
-- Optional: `env` for subprocess environments, `system_prompt` to override server prompt
+Local Config:
+- `command`: the command to run the server, e.g `python`, `npm`
+- `args`: the arguments to pass to the server as a list, e.g `["time/server.py"]`
+- Optional: `env`: for subprocess environments, `system_prompt` to override server prompt
 
-### 🔹 `namespaced_tools`
+Remote Config:
+- `url`: the url of the mcp server
+- Optional: `transport`: the type of transport, `http`, `sse`, `streamable-http`. Defaults to `http`
 
-If `true`, tools will be prefixed by server name (e.g., `weather-get_weather`).  
-Useful for disambiguating tool names across servers and avoiding name collision if multiple servers have the same tool name.
+## Environmental Variables
+
+There are two environmental variables:
+- `OPEN_AI_API_KEY`: required when using the `openai` provider, if using a local model with an openai compatible API it can be any string
+- `TOOL_RESULT_FORMAT`: adjusts the format of the tool result given back to the LLM. Options are `result`, `function_result`, `function_args_result`. Defaults to `result`
+
+You can set them using `export` or by creating a `.env` file.
 
 ## 🛠 CLI Reference
 
@@ -222,52 +228,48 @@ chat = McpToolChat(mcp_client, provider, system_prompt)
 response = await chat.chat(prompt="What time is it in London?")
 ```
 
-#### `MultiServerMCPClient`
-Connects to multiple MCP tool servers and manages available tools.
-
-```python
-from casual_mcp import MultiServerMCPClient
-
-mcp_client = MultiServerMCPClient()
-await mcp_client.load_config(config["servers"])
-tools = await mcp_client.list_tools()
-```
-
 #### `ProviderFactory`
 Instantiates LLM providers based on the selected model config.
 
 ```python
-from casual_mcp.providers.provider_factory import ProviderFactory
+from casual_mcp import ProviderFactory
 
 provider_factory = ProviderFactory()
 provider = provider_factory.get_provider("lm-qwen-3", model_config)
 ```
 
 #### `load_config`
-Loads your `config.json` into a validated config object.
+Loads your `casual_mcp_config.json` into a validated config object.
+
+```python
+from casual_mcp import load_config
+
+config = load_config("casual_mcp_config.json")
+```
+
+#### `load_mcp_client`
+Creats a multi server FastMCP client from the config object
 
 ```python
-from casual_mcp.utils import load_config
+from casual_mcp import load_mcp_client
 
-config = load_config("config.json")
+config = load_mcp_client(config)
 ```
 
 #### Model and Server Configs
 
 Exported models:
-- PythonMcpServerConfig
-- UvxMcpServerConfig
-- NodeMcpServerConfig
-- HttpMcpServerConfig
+- StdioServerConfig
+- RemoteServerConfig
 - OpenAIModelConfig
 
 Use these types to build valid configs:
 
 ```python
-from casual_mcp.models import OpenAIModelConfig, PythonMcpServerConfig
+from casual_mcp.models import OpenAIModelConfig, StdioServerConfig
 
-model = OpenAIModelConfig( model="llama3", endpoint="http://...")
-server = PythonMcpServerConfig(path="time/server.py")
+model = OpenAIModelConfig(model="llama3", endpoint="http://...")
+server = StdioServerConfig(command="python", args=["time/server.py"])
 ```
 
 #### Chat Messages
@@ -292,7 +294,7 @@ messages = [
 ### Example
 
 ```python
-from casual_mcp import McpToolChat, MultiServerMCPClient, load_config, ProviderFactory
+from casual_mcp import McpToolChat, load_config, load_mcp_client, ProviderFactory
 from casual_mcp.models import SystemMessage, UserMessage
 
 model = "gpt-4.1-nano"
@@ -304,10 +306,10 @@ Respond naturally and confidently, as if you already know all the facts."""),
 ]
 
 # Load the Config from the File
-config = load_config("config.json")
+config = load_config("casual_mcp_config.json")
 
 # Setup the MultiServer MCP Client
-mcp_client = MultiServerMCPClient()
+mcp_client = load_mcp_client(config)
 await mcp_client.load_config(config.servers)
 
 # Get the Provider for the Model

casual_mcp-0.2.2.dist-info/RECORD

@@ -0,0 +1,24 @@
+casual_mcp/__init__.py,sha256=qL2sZhhWrp60taGBHUG1yeelUgpxld-qXFEbEUMXZVM,277
+casual_mcp/cli.py,sha256=TSk12nXJH86f0WAR_u5hIJV9IAHeGHrkgFs7ZZ63Lug,1627
+casual_mcp/logging.py,sha256=o3rvT8GLJKGlu0ieeC9TY_SRSEUY-VO8jRQZjx-sSvY,863
+casual_mcp/main.py,sha256=1t702JABc1sFBzic7TMPE6OrikizBfOnlRpaY84p7oQ,3358
+casual_mcp/mcp_tool_chat.py,sha256=5PcbacNj3HR13Rnz4TDhxOtxfipNqGMgyTKHsaSAnV4,4249
+casual_mcp/utils.py,sha256=Nea0aRbPyjqm7mIjffJtGP2NssE7BsdPleO-yiuAWPE,2964
+casual_mcp/models/__init__.py,sha256=qlKylcCyRJOSIVteU2feiLOigZoY-m-soVGp4NALM_c,538
+casual_mcp/models/config.py,sha256=ITu3WAPMad7i2CS3ljkHapjT8lLm7k6HFUF6N73U1oo,294
+casual_mcp/models/generation_error.py,sha256=n1mF3vc1Sg_9yIe603G1nTP395Tht8JMKHqdMWFNAn0,259
+casual_mcp/models/mcp_server_config.py,sha256=0OHsHUEKxRoCl21lsye4E5GoCNmdZWIZCOOthcTpdsE,539
+casual_mcp/models/messages.py,sha256=7C0SoCC6Ee970iHprpCpsKsQrwvM66e39o96wfYm1Y8,683
+casual_mcp/models/model_config.py,sha256=gN5hNDfbur_bHgrji87CcU2WgNZO-F3eveK4pVWVSAE,435
+casual_mcp/models/tool_call.py,sha256=BKMxcmyW7EmNoG1jgS9PXXvf6RQIHf7wB8fElEbc4gA,271
+casual_mcp/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+casual_mcp/providers/abstract_provider.py,sha256=TTEP3FeTxOtbD0By_k17UxS8cqxYCOGNRTRxYRrqGwc,292
+casual_mcp/providers/ollama_provider.py,sha256=IUSJFBtEYmza_-_7bk5YZKqed3N67l8A2lZEmHPiyHo,2581
+casual_mcp/providers/openai_provider.py,sha256=uSjoqM-X9bVp_RVM8Ip6lqjZ7q3DdN0-p7o2HKrWxMI,6138
+casual_mcp/providers/provider_factory.py,sha256=CyFHJ0mU2tjHqj04btF0SL0B3pf12LAJ52Msqsbnv_g,1766
+casual_mcp-0.2.2.dist-info/licenses/LICENSE,sha256=U3Zu2tkrh5vXdy7gIdE8WJGM9D4gGp3hohAAWdre-yo,1058
+casual_mcp-0.2.2.dist-info/METADATA,sha256=z9WtBJF17iSjFXzj3vBIIK786LGO7Lx6VYv8SZGtX54,11954
+casual_mcp-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+casual_mcp-0.2.2.dist-info/entry_points.txt,sha256=X48Np2cwl-SlRQdV26y2vPZ-2tJaODgZeVtfpHho-zg,50
+casual_mcp-0.2.2.dist-info/top_level.txt,sha256=K4CiI0Jf8PHICjuQVm32HuNMB44kp8Lb02bbbdiH5bo,11
+casual_mcp-0.2.2.dist-info/RECORD,,

{casual_mcp-0.1.0.dist-info → casual_mcp-0.2.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

casual_mcp/multi_server_mcp_client.py

@@ -1,170 +0,0 @@
-import json
-import os
-
-import mcp
-from fastmcp import Client
-from fastmcp.client.logging import LogMessage
-from fastmcp.client.transports import (
-    ClientTransport,
-    NodeStdioTransport,
-    PythonStdioTransport,
-    StreamableHttpTransport,
-    UvxStdioTransport,
-)
-
-from casual_mcp.logging import get_logger
-from casual_mcp.models.mcp_server_config import McpServerConfig
-from casual_mcp.models.messages import ToolResultMessage
-from casual_mcp.models.tool_call import AssistantToolCall, AssistantToolCallFunction
-from casual_mcp.utils import format_tool_call_result
-
-logger = get_logger("multi_server_mcp_client")
-
-
-async def my_log_handler(params: LogMessage):
-    logger.log(params.level, params.data)
-
-
-def get_server_transport(config: McpServerConfig) -> ClientTransport:
-    match config.type:
-        case 'python':
-            return PythonStdioTransport(
-                script_path=config.path,
-                env=config.env
-            )
-        case 'node':
-            return NodeStdioTransport(
-                script_path=config.path,
-                env=config.env
-            )
-        case 'http':
-            return StreamableHttpTransport(
-                url=config.url
-                )
-        case 'uvx':
-            return UvxStdioTransport(
-                tool_name=config.package,
-                env_vars=config.env
-            )
-
-
-class MultiServerMCPClient:
-    def __init__(self, namespace_tools: bool = False):
-        self.servers: dict[str, Client] = {}  # Map server names to client connections
-        self.tools_map = {}  # Map tool names to server names
-        self.tools: list[mcp.types.Tool] = []
-        self.system_prompts: list[str] = []
-        self.namespace_tools = namespace_tools
-
-    async def load_config(self, config: dict[str, McpServerConfig]):
-        # Load the servers from config
-        logger.info("Loading server config")
-        for name, server_config in config.items():
-            transport = get_server_transport(server_config)
-            await self.connect_to_server(
-                transport,
-                name,
-                system_prompt=server_config.system_prompt
-            )
-
-
-    async def connect_to_server_script(self, path, name, env={}):
-        # Connect via stdio to a local script
-        transport = PythonStdioTransport(
-            script_path=path,
-            env=env,
-        )
-
-        return await self.connect_to_server(transport, name)
-
-    async def connect_to_server(self, server, name, system_prompt: str = None):
-        """Connect to an MCP server and register its tools."""
-        logger.debug(f"Connecting to server {name}")
-
-        async with Client(
-            server,
-            log_handler=my_log_handler,
-        ) as server_client:
-            # Store the connection
-            self.servers[name] = server_client
-
-            # Fetch tools and map them to this server
-            tools = await server_client.list_tools()
-
-            # If we are namespacing servers then change the tool names
-            for tool in tools:
-                if self.namespace_tools:
-                    tool.name = f"{name}-{tool.name}"
-                else:
-                    if self.tools_map.get(tool.name):
-                        raise SystemError(
-                            f"Tool name collision {name}:{tool.name} already added by {self.tools_map[tool.name]}"  # noqa: E501
-                        )
-
-                self.tools_map[tool.name] = name
-            self.tools.extend(tools)
-
-            if system_prompt:
-                prompt = await server_client.get_prompt(system_prompt)
-                if prompt:
-                    self.system_prompts.append(prompt)
-
-            return tools
-
-    async def list_tools(self):
-        """Fetch and aggregate tools from all connected servers."""
-        return self.tools
-
-    async def call_tool(self, function: AssistantToolCallFunction):
-        """Route a tool call to the appropriate server."""
-        tool_name = function.name
-        tool_args = json.loads(function.arguments)
-
-        # Find which server has this tool
-        server_name = self.tools_map.get(tool_name)
-
-        # Remove the sever name if the tools are namespaced
-        if self.namespace_tools:
-            tool_name = tool_name.removeprefix(f"{server_name}-")
-        else:
-            tool_name = tool_name
-
-        if not self.tools_map.get(tool_name):
-            raise ValueError(f"Tool not found: {tool_name}")
-
-        logger.info(f"Calling tool {tool_name}")
-
-        server_client = self.servers[server_name]
-        async with server_client:
-            return await server_client.call_tool(tool_name, tool_args)
-
-
-    async def execute(self, tool_call: AssistantToolCall):
-        try:
-            result = await self.call_tool(tool_call.function)
-        except Exception as e:
-            if isinstance(e, ValueError):
-                logger.warning(e)
-            else:
-                logger.error(f"Error calling tool: {e}")
-
-            return ToolResultMessage(
-                name=tool_call.function.name,
-                tool_call_id=tool_call.id,
-                content=str(e),
-            )
-
-        logger.debug(f"Tool Call Result: {result}")
-
-        result_format = os.getenv('TOOL_RESULT_FORMAT', 'result')
-        content = format_tool_call_result(tool_call, result[0].text, style=result_format)
-
-        return ToolResultMessage(
-            name=tool_call.function.name,
-            tool_call_id=tool_call.id,
-            content=content,
-        )
-
-
-    def get_system_prompts(self) -> list[str]:
-        return self.system_prompts

casual_mcp-0.1.0.dist-info/RECORD

@@ -1,25 +0,0 @@
-casual_mcp/__init__.py,sha256=UZTKF9qlKijDh2SRCbpz6nPi0now7hi4-VOJBnl7tTk,323
-casual_mcp/cli.py,sha256=s5-Mr2XNlzNcsfGwtwP25YBQYzf-orvDIu9gqwrVCI8,1561
-casual_mcp/logging.py,sha256=o3rvT8GLJKGlu0ieeC9TY_SRSEUY-VO8jRQZjx-sSvY,863
-casual_mcp/main.py,sha256=x-jJUltW4p4j0Vx-LaixbY0Oik6QZ81K2wdDeTNytME,3497
-casual_mcp/mcp_tool_chat.py,sha256=pIAQD-ghyLSGuLzXiG5Sv81-NHaNb5NVqRojJalwS1o,3113
-casual_mcp/multi_server_mcp_client.py,sha256=RrLO7wFGzkUgzmliagkOAx16lrvEG323MGPEU7Sw56o,5615
-casual_mcp/utils.py,sha256=8ekPpIfcqheMMjjKGe6lk81AWKpmCAixOXx_KJXGRAQ,2758
-casual_mcp/models/__init__.py,sha256=hHT-GBD0YMjHdJ4QGVefXQZsHu3bPd1vlizVdfYXoQ0,660
-casual_mcp/models/config.py,sha256=ITu3WAPMad7i2CS3ljkHapjT8lLm7k6HFUF6N73U1oo,294
-casual_mcp/models/generation_error.py,sha256=n1mF3vc1Sg_9yIe603G1nTP395Tht8JMKHqdMWFNAn0,259
-casual_mcp/models/mcp_server_config.py,sha256=o4uxq9JnrLRRHe0KNsaYE3P03wJdW1EmX18fmF7SoTQ,857
-casual_mcp/models/messages.py,sha256=5UASrYqlXeqaziDT8Zsej0kA7Ofce0109YlFAyQDuTY,688
-casual_mcp/models/model_config.py,sha256=gN5hNDfbur_bHgrji87CcU2WgNZO-F3eveK4pVWVSAE,435
-casual_mcp/models/tool_call.py,sha256=BKMxcmyW7EmNoG1jgS9PXXvf6RQIHf7wB8fElEbc4gA,271
-casual_mcp/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-casual_mcp/providers/abstract_provider.py,sha256=kACSVgPY9qTqD1IgIWY9HkS8US2B0Nm7MyGJk0GLfDk,307
-casual_mcp/providers/ollama_provider.py,sha256=DKX9QTDl9DspWJSghuQgOzHZgjmTVtf5uyRH_DeOgQc,2601
-casual_mcp/providers/openai_provider.py,sha256=VIymU3Jimncne0c1fyowy4BFBpyfK70eG-2rP_YGDzc,6153
-casual_mcp/providers/provider_factory.py,sha256=Bub4y4uHFc23VCOeRicT_Fi54IdcjHUgYAWPo1oiSo4,1519
-casual_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=U3Zu2tkrh5vXdy7gIdE8WJGM9D4gGp3hohAAWdre-yo,1058
-casual_mcp-0.1.0.dist-info/METADATA,sha256=PCJXGER8P8MgnqNBNRPVSysqumU4654KfUpUUyNLEdE,11576
-casual_mcp-0.1.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-casual_mcp-0.1.0.dist-info/entry_points.txt,sha256=X48Np2cwl-SlRQdV26y2vPZ-2tJaODgZeVtfpHho-zg,50
-casual_mcp-0.1.0.dist-info/top_level.txt,sha256=K4CiI0Jf8PHICjuQVm32HuNMB44kp8Lb02bbbdiH5bo,11
-casual_mcp-0.1.0.dist-info/RECORD,,