lm-deluge 0.0.8__py3-none-any.whl → 0.0.10__py3-none-any.whl

lm_deluge/tool.py

@@ -1,40 +1,222 @@
-from typing import Any, Dict, Literal, Callable
+from typing import Any, Literal, Callable, Coroutine, get_type_hints
+import inspect
+import asyncio
+
+from fastmcp import Client  # pip install fastmcp >= 2.0
+from mcp.types import Tool as MCPTool
 from pydantic import BaseModel, Field
 
 
-class ToolSpec(BaseModel):
+async def _load_all_mcp_tools(client: Client) -> list["Tool"]:
+    metas: list[MCPTool] = await client.list_tools()
+
+    def make_runner(name: str):
+        async def _async_call(**kw):
+            async with client:
+                # maybe should be call_tool_mcp if don't want to raise error
+                return await client.call_tool(name, kw)
+
+        return _async_call
+
+    tools: list[Tool] = []
+    for m in metas:
+        tools.append(
+            Tool(
+                name=m.name,
+                description=m.description,
+                parameters=m.inputSchema.get("properties", {}),
+                required=m.inputSchema.get("required", []),
+                additionalProperties=m.inputSchema.get("additionalProperties"),
+                run=make_runner(m.name),
+            )
+        )
+    return tools
+
+
+class Tool(BaseModel):
     """
     Provider‑agnostic tool definition with no extra nesting.
     """
 
     name: str
-    description: str
-    parameters: Dict[str, Any]
+    description: str | None
+    parameters: dict[str, Any]
     required: list[str] = Field(default_factory=list)
     additionalProperties: bool | None = None  # only
     # if desired, can provide a callable to run the tool
     run: Callable | None = None
 
+    def _is_async(self) -> bool:
+        return inspect.iscoroutinefunction(self.run)
+
     def call(self, **kwargs):
         if self.run is None:
             raise ValueError("No run function provided")
-        return self.run(**kwargs)
 
-    def _json_schema(self, include_additional_properties=False) -> Dict[str, Any]:
-        return {
+        if self._is_async():
+            coro: Coroutine = self.run(**kwargs)  # type: ignore[arg-type]
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                # no loop → safe to block
+                return asyncio.run(coro)
+            else:
+                # already inside a loop → schedule
+                return loop.create_task(coro)
+        else:
+            # plain function
+            return self.run(**kwargs)
+
+    async def acall(self, **kwargs):
+        if self.run is None:
+            raise ValueError("No run function provided")
+
+        if self._is_async():
+            return await self.run(**kwargs)  # type: ignore[func-returns-value]
+        else:
+            loop = asyncio.get_running_loop()
+            assert self.run is not None, "can't run None"
+            return await loop.run_in_executor(None, lambda: self.run(**kwargs))  # type: ignore
+
+    @classmethod
+    def from_function(cls, func: Callable) -> "Tool":
+        """Create a Tool from a function using introspection."""
+        # Get function name
+        name = func.__name__
+
+        # Get docstring for description
+        description = func.__doc__ or f"Call the {name} function"
+        description = description.strip()
+
+        # Get function signature and type hints
+        sig = inspect.signature(func)
+        type_hints = get_type_hints(func)
+
+        # Build parameters and required list
+        parameters = {}
+        required = []
+
+        for param_name, param in sig.parameters.items():
+            # Skip *args and **kwargs
+            if param.kind in (param.VAR_POSITIONAL, param.VAR_KEYWORD):
+                continue
+
+            # Get type hint
+            param_type = type_hints.get(param_name, str)
+
+            # Convert Python types to JSON Schema types
+            json_type = cls._python_type_to_json_schema(param_type)
+
+            parameters[param_name] = json_type
+
+            # Add to required if no default value
+            if param.default is param.empty:
+                required.append(param_name)
+
+        return cls(
+            name=name,
+            description=description,
+            parameters=parameters,
+            required=required,
+            run=func,
+        )
+
+    @classmethod
+    async def from_mcp_config(
+        cls,
+        config: dict[str, Any],
+        *,
+        timeout: float | None = None,
+    ) -> list["Tool"]:
+        """
+        config: full Claude-Desktop-style dict *or* just its "mcpServers" block
+        Returns {server_key: [Tool, …], …}
+        """
+        # allow caller to pass either the whole desktop file or just the sub-dict
+        servers_block = config.get("mcpServers", config)
+
+        # FastMCP understands the whole config dict directly
+        client = Client({"mcpServers": servers_block}, timeout=timeout)
+        async with client:
+            all_tools = await _load_all_mcp_tools(client)
+
+        # bucket by prefix that FastMCP added (serverkey_toolname)
+        return all_tools
+
+    @classmethod
+    async def from_mcp(
+        cls,
+        server_name: str,
+        *,
+        tool_name: str,
+        timeout: float | None = None,
+        **server_spec,  # url="…"  OR  command="…" args=[…]
+    ) -> Any:  # Tool | list[Tool]
+        """
+        Thin wrapper for one server.  Example uses:
+
+            Tool.from_mcp(url="https://weather.example.com/mcp")
+            Tool.from_mcp(command="python", args=["./assistant.py"], tool_name="answer_question")
+        """
+        # ensure at least one of command or url is defined
+        if not (server_spec.get("url") or server_spec.get("command")):
+            raise ValueError("most provide url or command")
+        # build a one-server desktop-style dict
+        cfg = {server_name: server_spec}
+        tools = await cls.from_mcp_config(cfg, timeout=timeout)
+        if tool_name is None:
+            return tools
+        for t in tools:
+            if t.name.endswith(f"{tool_name}"):  # prefixed by FastMCP
+                return t
+        raise ValueError(f"Tool '{tool_name}' not found on that server")
+
+    @staticmethod
+    def _tool_from_meta(meta: dict[str, Any], runner) -> "Tool":
+        props = meta["inputSchema"].get("properties", {})
+        req = meta["inputSchema"].get("required", [])
+        addl = meta["inputSchema"].get("additionalProperties")
+        return Tool(
+            name=meta["name"],
+            description=meta.get("description", ""),
+            parameters=props,
+            required=req,
+            additionalProperties=addl,
+            run=runner,
+        )
+
+    @staticmethod
+    def _python_type_to_json_schema(python_type: type) -> dict[str, Any]:
+        """Convert Python type to JSON Schema type definition."""
+        if python_type is int:
+            return {"type": "integer"}
+        elif python_type is float:
+            return {"type": "number"}
+        elif python_type is str:
+            return {"type": "string"}
+        elif python_type is bool:
+            return {"type": "boolean"}
+        elif python_type is list:
+            return {"type": "array"}
+        elif python_type is dict:
+            return {"type": "object"}
+        else:
+            # Default to string for unknown types
+            return {"type": "string"}
+
+    def _json_schema(self, include_additional_properties=False) -> dict[str, Any]:
+        res = {
             "type": "object",
             "properties": self.parameters,
-            "required": self.required or [],
-            **(
-                {"additionalProperties": self.additionalProperties}
-                if self.additionalProperties is not None
-                and include_additional_properties
-                else {}
-            ),
+            "required": self.required,  # Use the tool's actual required list
         }
+        if include_additional_properties:
+            res["additionalProperties"] = False
+
+        return res
 
     # ---------- dumpers ----------
-    def for_openai_responses(self) -> Dict[str, Any]:
+    def for_openai_responses(self) -> dict[str, Any]:
         return {
             "type": "function",
             "name": self.name,
@@ -42,25 +224,35 @@ class ToolSpec(BaseModel):
             "parameters": self._json_schema(include_additional_properties=True),
         }
 
-    def for_openai_completions(self, *, strict: bool = True) -> Dict[str, Any]:
+    def for_openai_completions(self, *, strict: bool = True) -> dict[str, Any]:
+        if strict:
+            # For strict mode, all parameters must be required and additionalProperties must be false
+            schema = self._json_schema(include_additional_properties=True)
+            schema["required"] = list(
+                self.parameters.keys()
+            )  # All parameters required in strict mode
+        else:
+            # For non-strict mode, use the original required list
+            schema = self._json_schema(include_additional_properties=True)
+
         return {
             "type": "function",
             "function": {
                 "name": self.name,
                 "description": self.description,
-                "parameters": self._json_schema(),
+                "parameters": schema,
                 "strict": strict,
             },
         }
 
-    def for_anthropic(self) -> Dict[str, Any]:
+    def for_anthropic(self) -> dict[str, Any]:
         return {
             "name": self.name,
             "description": self.description,
             "input_schema": self._json_schema(),
         }
 
-    def for_google(self) -> Dict[str, Any]:
+    def for_google(self) -> dict[str, Any]:
         """
         Shape used by google.genai docs.
         """
@@ -76,7 +268,7 @@ class ToolSpec(BaseModel):
             "openai-responses", "openai-completions", "anthropic", "google"
         ],
         **kw,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         if provider == "openai-responses":
             return self.for_openai_responses()
         if provider == "openai-completions":
@@ -86,21 +278,3 @@ class ToolSpec(BaseModel):
         if provider == "google":
             return self.for_google()
         raise ValueError(provider)
-
-
-# ---- computer tools (for non-CUA models) ----
-_BUTTONS = ["left", "right", "wheel", "back", "forward"]
-
-# --- helpers ----
-_COORD_OBJECT = {
-    "type": "object",
-    "properties": {
-        "x": {"type": "integer", "description": "X-coordinate in pixels"},
-        "y": {"type": "integer", "description": "Y-coordinate in pixels"},
-    },
-    "required": ["x", "y"],
-}
-
-
-def _coord_field(desc: str):
-    return {"type": "integer", "description": desc}

{lm_deluge-0.0.8.dist-info → lm_deluge-0.0.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.8
+Version: 0.0.10
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10
@@ -21,6 +21,7 @@ Requires-Dist: bs4
 Requires-Dist: lxml
 Requires-Dist: pdf2image
 Requires-Dist: pillow
+Requires-Dist: fastmcp>=2.4
 Requires-Dist: fasttext-wheel
 Requires-Dist: fasttext-langdetect
 Dynamic: license-file
@@ -32,6 +33,8 @@ Dynamic: license-file
 - **Unified client** – Send prompts to all relevant models with a single client.
 - **Massive concurrency with throttling** – Set `max_tokens_per_minute` and `max_requests_per_minute` and let it fly. The client will process as many requests as possible while respecting rate limits and retrying failures.
 - **Spray across models/providers** – Configure a client with multiple models from any provider(s), and sampling weights. The client samples a model for each request.
+- **Tool Use** – Unified API for defining tools for all providers, and creating tools automatically from python functions.
+- **MCP Support** – Instantiate a `Tool` from a local or remote MCP server so that any LLM can use it, whether or not that provider natively supports MCP.
 - **Caching** – Save completions in a local or distributed cache to avoid repeated LLM calls to process the same input.
 - **Convenient message constructor** – No more looking up how to build an Anthropic messages list with images. Our `Conversation` and `Message` classes work great with our client or with the `openai` and `anthropic` packages.
 - **Sync and async APIs** – Use the client from sync or async code.

{lm_deluge-0.0.8.dist-info → lm_deluge-0.0.10.dist-info}/RECORD

@@ -1,22 +1,23 @@
 lm_deluge/__init__.py,sha256=rndOr4Rcfnpttz-onWU3vVEm-MM0WDFgz6KexKPAx0k,222
 lm_deluge/cache.py,sha256=VB1kv8rM2t5XWPR60uhszFcxLDnVKOe1oA5hYjVDjIo,4375
-lm_deluge/client.py,sha256=ERH0SkNvdM1zc8HYS5dxRGxVxUb4CXpUhveG3mz-w2I,28533
+lm_deluge/client.py,sha256=lGD4rqT7qHkTKddjRvKK_1bh7s8GNIzXzQ52GCZhfCg,28932
 lm_deluge/embed.py,sha256=m-X8UK4gV9KKD7Wv3yarAceMQaj7gR1JwzD_sB0MOQY,13183
 lm_deluge/errors.py,sha256=oHjt7YnxWbh-eXMScIzov4NvpJMo0-2r5J6Wh5DQ1tk,209
 lm_deluge/gemini_limits.py,sha256=V9mpS9JtXYz7AY6OuKyQp5TuIMRH1BVv9YrSNmGmHNA,1569
 lm_deluge/image.py,sha256=hFbRajqEVQbkirAfOxsTPkeq-27Zl-so4AWBFeUbpBI,7161
-lm_deluge/models.py,sha256=w_OqA4Jxcy8LCCcdPRsGzg8iLFv4S9fPS5b4oj82Bgs,42778
-lm_deluge/prompt.py,sha256=bhDAlfUQ_Fq6Wh-L9jOfoiMbDGyVKGkjGicnwKJWpcI,12680
+lm_deluge/models.py,sha256=6c_UZ3KlygpHpF0nq1_MRLtgOBdB1Q6FffLgm4ye_t0,44999
+lm_deluge/prompt.py,sha256=_pJYwgjL39lDzMNmae8pPIBoORm_ekSM_9qU2iGGpOc,25445
 lm_deluge/rerank.py,sha256=tW1c3gQCAqaF8Ez-r-4qxYAcdKqxnLMxwHApKOUKwk4,11289
 lm_deluge/sampling_params.py,sha256=E2kewh1vz-1Qcy5xNBCzihfGgT_GcHYMfzaWb3FLiXs,739
-lm_deluge/tool.py,sha256=RVUW3E3FW11jCM-R7pIL1GpRs1YKCOjvTkL1D5xPetk,3196
+lm_deluge/tool.py,sha256=3hlOTdm-RJMGHOU2tI_quJa2UNIrXPT8hxGb3mnheAg,9462
 lm_deluge/tracker.py,sha256=Dk99scN_NeDEO0gkLO5efXiZq11Ga-k6cerUHWN7IWY,1292
 lm_deluge/api_requests/__init__.py,sha256=_aSpD6CJL9g6OpLPoChXiHjl4MH_OlGcKgfZaW8cgLM,71
-lm_deluge/api_requests/anthropic.py,sha256=URbiD-ANn_P3StFJVP2JoDWuoloZVsAUly8CGSyV2Kw,6618
-lm_deluge/api_requests/base.py,sha256=Yt5Bxd5C5mZrbAMQYDghk0KRhUChSbTEsVI8DoThZBs,14805
-lm_deluge/api_requests/common.py,sha256=EjwTnKrvgBx-HnRVt0kSJZ9RM7CM-QyhlIQkr1jxP-4,220
-lm_deluge/api_requests/mistral.py,sha256=ThlV1jBfhpAwkaqPKhdUq-lIq2OienRbhEaSK4cctvI,5370
-lm_deluge/api_requests/openai.py,sha256=YgJMUio23ks6VLv6BDBZAW6Bnfd2fpidSidaHXzyXFY,6135
+lm_deluge/api_requests/anthropic.py,sha256=MMI_w9hVbevQpcqP3NVVindpTmLb2KHqjJQpIzCi5RM,7240
+lm_deluge/api_requests/base.py,sha256=w0MEOCIccxxy2c67Y2Y-QBox9rinIxQ7MLnp8953sjQ,15954
+lm_deluge/api_requests/bedrock.py,sha256=cvB85BFvL9HKTUsP9qFUCLQzJh83IQNAcLXuW6ReZK8,10520
+lm_deluge/api_requests/common.py,sha256=U0mX_wC3Tzg2-1u9nYUCTQqYzuYJqvLrICCNW_dbbJM,287
+lm_deluge/api_requests/mistral.py,sha256=gCi4R61oh759ZX6TKrT-fnQwIQaOGcPXhWrDsjJwPOY,5388
+lm_deluge/api_requests/openai.py,sha256=BuMiM_2zJQXfnUjTT94JxJi3ZX5V-KQQueRG-R0SGuc,7361
 lm_deluge/api_requests/deprecated/bedrock.py,sha256=WrcIShCoO8JCUSlFOCHxg6KQCNTZfw3TpYTvSpYk4mA,11320
 lm_deluge/api_requests/deprecated/cohere.py,sha256=KgDScD6_bWhAzOY5BHZQKSA3kurt4KGENqC4wLsGmcU,5142
 lm_deluge/api_requests/deprecated/deepseek.py,sha256=FEApI93VAWDwuaqTooIyKMgONYqRhdUmiAPBRme-IYs,4582
@@ -30,8 +31,8 @@ lm_deluge/util/json.py,sha256=dCeG9j1D17rXmQJbKJH79X0CGof4Wlqd55TDg4D6ky8,5388
 lm_deluge/util/logprobs.py,sha256=UkBZakOxWluaLqHrjARu7xnJ0uCHVfLGHJdnYlEcutk,11768
 lm_deluge/util/validation.py,sha256=hz5dDb3ebvZrZhnaWxOxbNSVMI6nmaOODBkk0htAUhs,1575
 lm_deluge/util/xml.py,sha256=Ft4zajoYBJR3HHCt2oHwGfymGLdvp_gegVmJ-Wqk4Ck,10547
-lm_deluge-0.0.8.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
-lm_deluge-0.0.8.dist-info/METADATA,sha256=sRRWcI9rQ0BlCENlRF6EdY-eJY-p9CTAFmak8tstGOM,8076
-lm_deluge-0.0.8.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-lm_deluge-0.0.8.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
-lm_deluge-0.0.8.dist-info/RECORD,,
+lm_deluge-0.0.10.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.10.dist-info/METADATA,sha256=hn8Arn1L8N9PDaPJzZtnDB9WMVZsm1Ur7suIq3jYvZs,8387
+lm_deluge-0.0.10.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+lm_deluge-0.0.10.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.10.dist-info/RECORD,,