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

lm_deluge/client.py

@@ -9,7 +9,7 @@ from typing import Sequence, overload, Literal, Any
 from tqdm.auto import tqdm
 
 from lm_deluge.prompt import Conversation
-from lm_deluge.tool import ToolSpec
+from lm_deluge.tool import Tool
 
 from .tracker import StatusTracker
 from .sampling_params import SamplingParams
@@ -231,7 +231,7 @@ class LLMClient:
         show_progress: bool = ...,
         dry_run: Literal[True],
         verbose: bool = ...,
-        tools: list[ToolSpec] | None = ...,
+        tools: list[Tool] | None = ...,
     ) -> dict[str, int]: ...
 
     @overload
@@ -243,7 +243,7 @@ class LLMClient:
         show_progress: bool = ...,
         dry_run: bool = ...,
         verbose: bool = ...,
-        tools: list[ToolSpec] | None = ...,
+        tools: list[Tool] | None = ...,
     ) -> list[str | None]: ...
 
     @overload
@@ -255,7 +255,7 @@ class LLMClient:
         show_progress: bool = ...,
         dry_run: bool = ...,
         verbose: bool = ...,
-        tools: list[ToolSpec] | None = ...,
+        tools: list[Tool] | None = ...,
     ) -> list[APIResponse | None]: ...
 
     async def process_prompts_async(
@@ -266,7 +266,7 @@ class LLMClient:
         show_progress: bool = True,
         dry_run: bool = False,
         verbose: bool = False,
-        tools: list[ToolSpec] | None = None,
+        tools: list[Tool] | None = None,
     ) -> list[APIResponse | None] | list[str | None] | dict[str, int]:
         # if prompts are not Conversations, convert them.
         # can only handle strings for now
@@ -372,7 +372,7 @@ class LLMClient:
         show_progress=True,
         dry_run: bool = False,
         verbose: bool = False,
-        tools: list[ToolSpec] | None = None,
+        tools: list[Tool] | None = None,
     ):
         return asyncio.run(
             self.process_prompts_async(
@@ -569,7 +569,7 @@ async def process_api_prompts_async(
     progress_bar: tqdm | None = None,
     use_qps: bool = False,
     verbose: bool = False,
-    tools: list[ToolSpec] | None = None,
+    tools: list[Tool] | None = None,
 ):
     """Processes API requests in parallel, throttling to stay under rate limits."""
     # change ids to integer list

lm_deluge/models.py

@@ -664,7 +664,7 @@ registry = {
         "output_cost": 15.0,
         "requests_per_minute": 4_000,
         "tokens_per_minute": 400_000,
-        "reasoning_model": True,
+        "reasoning_model": False,
     },
     "claude-3.6-sonnet-bedrock": {
         "id": "claude-3.6-sonnet-bedrock",
@@ -677,10 +677,10 @@ registry = {
         "output_cost": 15.0,
         "requests_per_minute": 4_000,
         "tokens_per_minute": 400_000,
-        "reasoning_model": True,
+        "reasoning_model": False,
     },
-    "claude-sonnet-3.7-bedrock": {
-        "id": "claude-sonnet-3.7-bedrock",
+    "claude-3.7-sonnet-bedrock": {
+        "id": "claude-3.7-sonnet-bedrock",
         "name": "us.anthropic.claude-3-7-sonnet-20250219-v1:0",
         "regions": ["us-east-1", "us-west-2", "eu-west-1"],
         "api_base": "",
@@ -692,8 +692,8 @@ registry = {
         "tokens_per_minute": 400_000,
         "reasoning_model": True,
     },
-    "claude-sonnet-4-bedrock": {
-        "id": "claude-sonnet-4-bedrock",
+    "claude-4-sonnet-bedrock": {
+        "id": "claude-4-sonnet-bedrock",
         "name": "us.anthropic.claude-sonnet-4-20250514-v1:0",
         "regions": ["us-east-1", "us-west-2", "us-east-2"],
         "api_base": "",
@@ -703,10 +703,10 @@ registry = {
         "output_cost": 15.0,
         "requests_per_minute": 4_000,
         "tokens_per_minute": 400_000,
-        "reasoning_model": False,
+        "reasoning_model": True,
     },
-    "claude-opus-4-bedrock": {
-        "id": "claude-opus-4-bedrock",
+    "claude-4-opus-bedrock": {
+        "id": "claude-4-opus-bedrock",
         "name": "us.anthropic.claude-opus-4-20250514-v1:0",
         "regions": ["us-east-1", "us-west-2", "us-east-2"],
         "api_base": "",

lm_deluge/tool.py

@@ -1,31 +1,214 @@
-from typing import Any, 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
+    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)
+
+        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,
-            # for openai all must be required
-            "required": list(self.parameters.keys()),
+            "required": self.required,  # Use the tool's actual required list
         }
         if include_additional_properties:
             res["additionalProperties"] = False
@@ -42,12 +225,22 @@ class ToolSpec(BaseModel):
         }
 
     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(include_additional_properties=True),
+                "parameters": schema,
                 "strict": strict,
             },
         }

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.9
+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.9.dist-info → lm_deluge-0.0.10.dist-info}/RECORD

@@ -1,15 +1,15 @@
 lm_deluge/__init__.py,sha256=rndOr4Rcfnpttz-onWU3vVEm-MM0WDFgz6KexKPAx0k,222
 lm_deluge/cache.py,sha256=VB1kv8rM2t5XWPR60uhszFcxLDnVKOe1oA5hYjVDjIo,4375
-lm_deluge/client.py,sha256=rk0YAUvC5kF3OuxnmYlkT8I6NjAmEJ6TUfryQbRkmXw,28960
+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=qdUsHC1kz82ZwduUU_rBcvJP4j2JXCL3Q2RtbHWc1H8,44998
+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=zXletfGtpgBCXuqietZn-eaOItbIyOROskTbaSjfwEk,2701
+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=MMI_w9hVbevQpcqP3NVVindpTmLb2KHqjJQpIzCi5RM,7240
@@ -31,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.9.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
-lm_deluge-0.0.9.dist-info/METADATA,sha256=hIv-9R30IJXuh6AHR0pZkktvsbSihThOuu9D9AniKIg,8076
-lm_deluge-0.0.9.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-lm_deluge-0.0.9.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
-lm_deluge-0.0.9.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,,