casual-mcp 0.1.0__py3-none-any.whl

casual_mcp/providers/ollama_provider.py

@@ -0,0 +1,72 @@
+from typing import Any
+
+import mcp
+import ollama
+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.providers.abstract_provider import CasualMcpProvider
+
+logger = get_logger("providers.ollama")
+
+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]:
+    raise Exception({"message": "under development"})
+
+
+def convert_tool_calls(response_tool_calls: list[ollama.Message.ToolCall]) -> list[dict[str, Any]]:
+    raise Exception({"message": "under development"})
+
+
+class OllamaProvider(CasualMcpProvider):
+    def __init__(self, model: str, endpoint: str = None):
+        self.model = model
+        self.client = Client(
+            host=endpoint,
+        )
+
+    async def generate(
+        self,
+        messages: list[CasualMcpMessage],
+        tools: list[mcp.Tool]
+    ) -> CasualMcpMessage:
+        logger.info("Start Generating")
+        logger.debug(f"Model: {self.model}")
+
+        # Convert tools to Ollama format
+        converted_tools = convert_tools(tools)
+        logger.debug(f"Converted Tools: {converted_tools}")
+        logger.info(f"Adding {len(converted_tools)} tools")
+
+        # Convert Messages to Ollama format
+        converted_messages = convert_messages(messages)
+        logger.debug(f"Converted Messages: {converted_messages}")
+
+        # Call Ollama API
+        try:
+            response: ChatResponse = self.client.chat(
+                model=self.model, messages=converted_messages, stream=False, tools=converted_tools
+            )
+        except ResponseError as e:
+            if e.status_code == 404:
+                logger.info(f"Model {self.model} not found, pulling")
+                self.client.pull(self.model)
+                return self.generate(messages, tools)
+
+            raise e
+        except Exception as e:
+            logger.warning(f"Error in Generation: {e}")
+            raise GenerationError(str(e))
+
+        # Convert any tool calls
+        tool_calls = []
+        if hasattr(response.message, "tool_calls") and response.message.tool_calls:
+            logger.debug(f"Assistant requested {len(response.message.tool_calls)} tool calls")
+            tool_calls = convert_tool_calls(response.message.tool_calls)
+
+        return AssistantMessage(content=response.message.content, tool_calls=tool_calls)

casual_mcp/providers/openai_provider.py

@@ -0,0 +1,178 @@
+from typing import Any
+
+import mcp
+from openai import OpenAI
+from openai.types.chat import (
+    ChatCompletionAssistantMessageParam,
+    ChatCompletionMessageParam,
+    ChatCompletionMessageToolCall,
+    ChatCompletionMessageToolCallParam,
+    ChatCompletionSystemMessageParam,
+    ChatCompletionToolMessageParam,
+    ChatCompletionToolParam,
+    ChatCompletionUserMessageParam,
+)
+
+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.tool_call import AssistantToolCall, AssistantToolCallFunction
+from casual_mcp.providers.abstract_provider import CasualMcpProvider
+
+logger = get_logger("providers.openai")
+
+MessageType = dict[str, Any]
+
+
+def convert_tools(mcp_tools: list[mcp.Tool]) -> list[ChatCompletionToolParam]:
+    logger.info("Converting MCP tools to OpenAI format")
+    tools = []
+
+    # Convert all the tools
+    for i, mcp_tool in enumerate(mcp_tools):
+        if mcp_tool.name and mcp_tool.description:
+            # Convert the tool
+            tool = convert_tool(mcp_tool)
+            tools.append(tool)
+        else:
+            logger.warning(
+                f"Tool missing attributes: name = {mcp_tool.name}, description = {mcp_tool.description}"  # noqa: E501
+            )
+
+    return tools
+
+
+def convert_tool(mcp_tool: mcp.Tool) -> ChatCompletionToolParam | None:
+    logger.debug(f"Converting: {mcp_tool.name}")
+    tool = {
+        "type": "function",
+        "function": {
+            "name": mcp_tool.name,
+            "description": mcp_tool.description,
+            "parameters": {
+                "type": "object",
+                "properties": mcp_tool.inputSchema["properties"],
+                "required": mcp_tool.inputSchema.get("required", []),
+            },
+        },
+    }
+    return ChatCompletionToolParam(**tool)
+
+
+def convert_messages(messages: list[CasualMcpMessage]) -> list[ChatCompletionMessageParam]:
+    if not messages:
+        return messages
+
+    logger.info("Converting messages to OpenAI format")
+
+    openai_messages: list[ChatCompletionMessageParam] = []
+    for msg in messages:
+        match msg.role:
+            case "assistant":
+                tool_calls = None
+                if msg.tool_calls:
+                    tool_calls = []
+                    for tool_call in msg.tool_calls:
+                        function = {
+                            "name": tool_call.function.name,
+                            "arguments": tool_call.function.arguments
+                        }
+                        tool_calls.append(
+                            ChatCompletionMessageToolCallParam(
+                                id=tool_call.id,
+                                type=tool_call.type,
+                                function=function
+                            )
+                        )
+                openai_messages.append(
+                    ChatCompletionAssistantMessageParam(
+                        role="assistant", content=msg.content, tool_calls=tool_calls
+                    )
+                )
+            case "system":
+                openai_messages.append(
+                    ChatCompletionSystemMessageParam(role="system", content=msg.content)
+                )
+            case "tool":
+                openai_messages.append(
+                    ChatCompletionToolMessageParam(
+                        role="tool", content=msg.content, tool_call_id=msg.tool_call_id
+                    )
+                )
+            case "user":
+                openai_messages.append(
+                    ChatCompletionUserMessageParam(role="user", content=msg.content)
+                )
+
+    return openai_messages
+
+
+def convert_tool_calls(
+    response_tool_calls: list[ChatCompletionMessageToolCall],
+) -> list[AssistantToolCall]:
+    tool_calls = []
+
+    for i, tool in enumerate(response_tool_calls):
+        logger.debug(f"Convert Tool: {tool}")
+
+        # Create the tool object in the format expected by client.py
+        tool_call = AssistantToolCall(
+            id=tool.id,
+            function=AssistantToolCallFunction(
+                name=tool.function.name,
+                type="function",
+                arguments=tool.function.arguments
+            )
+        )
+        tool_calls.append(tool_call)
+
+    return tool_calls
+
+
+class OpenAiProvider(CasualMcpProvider):
+    def __init__(self, model: str, api_key: str, tools: list[mcp.Tool], endpoint: str = None):
+
+        # Convert MCP Tools to OpenAI format
+        self.tools = convert_tools(tools)
+        logger.debug(f"Converted Tools: {self.tools}")
+        logger.info(f"Adding {len(self.tools)} tools")
+        self.model = model
+        self.client = OpenAI(
+            base_url=endpoint,
+            api_key=api_key,
+        )
+
+    async def generate(
+        self,
+        messages: list[CasualMcpMessage],
+        tools: list[mcp.Tool]
+    ) -> AssistantMessage:
+        logger.info("Start Generating")
+        logger.debug(f"Model: {self.model}")
+
+        # Convert Messages to OpenAI format
+        converted_messages = convert_messages(messages)
+        logger.debug(f"Converted Messages: {converted_messages}")
+        logger.info(f"Adding {len(converted_messages)} messages")
+
+        # Call OpenAi API
+        try:
+            result = self.client.chat.completions.create(
+                model=self.model, messages=converted_messages, tools=self.tools
+            )
+
+            response = result.choices[0]
+        except Exception as e:
+            logger.warning(f"Error in Generation: {e}")
+            raise GenerationError(str(e))
+
+        logger.debug(response)
+
+        # Convert any tool calls
+        tool_calls = None
+        if hasattr(response.message, "tool_calls") and response.message.tool_calls:
+            logger.debug(f"Assistant requested {len(response.message.tool_calls)} tool calls")
+            tool_calls = convert_tool_calls(response.message.tool_calls)
+            logger.debug(f"Converted {len(tool_calls)} tool calls")
+
+        return AssistantMessage(content=response.message.content, tool_calls=tool_calls)

casual_mcp/providers/provider_factory.py

@@ -0,0 +1,48 @@
+import os
+from typing import TypeAlias
+
+import mcp
+
+from casual_mcp.logging import get_logger
+from casual_mcp.models.model_config import ModelConfig
+from casual_mcp.providers.ollama_provider import OllamaProvider
+from casual_mcp.providers.openai_provider import OpenAiProvider
+
+logger = get_logger("providers.factory")
+
+LLMProvider: TypeAlias = OpenAiProvider | OllamaProvider
+
+class ProviderFactory:
+    def __init__(self):
+        self.providers: dict[str, LLMProvider] = {}
+
+
+    def set_tools(self, tools: list[mcp.Tool]):
+        self.tools = tools
+
+
+    def get_provider(self, name: str, config: ModelConfig) -> LLMProvider:
+        if self.providers.get(name):
+            return self.providers.get(name)
+
+        match config.provider:
+            case "ollama":
+                logger.info(f"Creating Ollama provider for {config.model} at {config.endpoint}")
+                provider = OllamaProvider(config.model, endpoint=config.endpoint.__str__())
+
+            case "openai":
+                endpoint = None
+                if config.endpoint:
+                    endpoint = config.endpoint.__str__()
+
+                logger.info(f"Creating OpenAI provider for {config.model} at {endpoint}")
+                api_key = os.getenv("OPEN_AI_API_KEY")
+                provider = OpenAiProvider(
+                    config.model,
+                    api_key,
+                    self.tools,
+                    endpoint=endpoint,
+                )
+
+        self.providers[name] = provider
+        return provider

casual_mcp/utils.py

@@ -0,0 +1,90 @@
+import json
+from pathlib import Path
+
+import mcp
+from jinja2 import Environment, FileSystemLoader
+from pydantic import ValidationError
+
+from casual_mcp.models.config import Config
+from casual_mcp.models.tool_call import AssistantToolCall
+
+
+def load_config(path: str | Path) -> Config:
+    path = Path(path)
+
+    if not path.exists():
+        raise FileNotFoundError(f"Config file not found: {path}")
+
+    try:
+        with path.open("r", encoding="utf-8") as f:
+            raw_data = json.load(f)
+
+        return Config(**raw_data)
+    except ValidationError as ve:
+        raise ValueError(f"Invalid config:\n{ve}") from ve
+    except json.JSONDecodeError as je:
+        raise ValueError(f"Could not parse config JSON:\n{je}") from je
+
+def format_tool_call_result(
+    tool_call: AssistantToolCall,
+    result: str,
+    style: str = "function_result",
+    include_id: bool = False
+    ) -> str:
+    """
+    Format a tool call and result into a prompt-friendly string.
+
+    Supported styles:
+        - "result": Only the result text
+        - "function_result": function → result
+        - "function_args_result": function(args) → result
+
+    Include ID to add the tool call ID above the result
+
+    Args:
+        tool_call (AssistantToolCall): Tool call
+        result (str): Output of the tool
+        style (str): One of the supported formatting styles
+        include_id (bool): Whether to include the tool call ID
+
+    Returns:
+        str: Formatted content string
+    """
+    func_name = tool_call.function.name
+    args = json.loads(tool_call.function.arguments)
+
+    if style == "result":
+        result_str = result
+
+    elif style == "function_result":
+        result_str = f"{func_name} → {result}"
+
+    elif style == "function_args_result":
+        arg_string = ", ".join(f"{k}={repr(v)}" for k, v in args.items())
+        result_str = f"{func_name}({arg_string}) → {result}"
+
+    else:
+        raise ValueError(f"Unsupported style: {style}")
+
+    if (include_id):
+        return f"ID: {tool_call.id}\n{result_str}"
+
+    return result_str
+
+
+def render_system_prompt(template_name: str, tools: list[mcp.Tool], extra: dict = None) -> str:
+    """
+    Renders a system prompt template with tool definitions.
+
+    :param template_name: e.g. 'stealth_tools_prompt.j2'
+    :param tools: list of dicts with 'name' and 'description' (at minimum)
+    :param extra: optional additional variables for template
+    :return: rendered system prompt
+    """
+    TEMPLATE_DIR = Path("prompt-templates").resolve()
+    env = Environment(loader=FileSystemLoader(TEMPLATE_DIR), autoescape=False)
+    template = env.get_template(template_name)
+    context = {"tools": tools}
+    if extra:
+        context.update(extra)
+    return template.render(**context)