lm-deluge 0.0.80__py3-none-any.whl → 0.0.82__py3-none-any.whl

lm_deluge/{tool.py → tool/__init__.py}

@@ -1,12 +1,13 @@
 import asyncio
 import inspect
 from concurrent.futures import ThreadPoolExecutor
+from functools import lru_cache
 from typing import (
+    Annotated,
     Any,
     Callable,
     Coroutine,
     Literal,
-    Type,
     TypedDict,
     get_args,
     get_origin,
@@ -15,13 +16,334 @@ from typing import (
 
 from fastmcp import Client  # pip install fastmcp >= 2.0
 from mcp.types import Tool as MCPTool
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field, TypeAdapter, field_validator
 
 from lm_deluge.image import Image
 from lm_deluge.prompt import Text, ToolResultPart
 
 
-def _python_type_to_json_schema_enhanced(python_type: Any) -> dict[str, Any]:
+@lru_cache(maxsize=1000)
+def _get_cached_typeadapter(cls: type | Callable) -> TypeAdapter:
+    """
+    Cache TypeAdapters since they're expensive to create.
+    For functions, we also handle Annotated[T, "string"] -> Annotated[T, Field(description="string")].
+    """
+    if inspect.isfunction(cls) or inspect.ismethod(cls):
+        if hasattr(cls, "__annotations__") and cls.__annotations__:
+            try:
+                resolved_hints = get_type_hints(cls, include_extras=True)
+            except Exception:
+                resolved_hints = cls.__annotations__
+
+            # Convert Annotated[T, "string"] to Annotated[T, Field(description="string")]
+            processed_hints = {}
+            for name, annotation in resolved_hints.items():
+                if (
+                    get_origin(annotation) is Annotated
+                    and len(get_args(annotation)) == 2
+                    and isinstance(get_args(annotation)[1], str)
+                ):
+                    base_type, description = get_args(annotation)
+                    processed_hints[name] = Annotated[
+                        base_type, Field(description=description)
+                    ]
+                else:
+                    processed_hints[name] = annotation
+
+            # Create new function with processed annotations if changed
+            if processed_hints != cls.__annotations__:
+                import types
+
+                if inspect.ismethod(cls):
+                    actual_func = cls.__func__
+                    code = actual_func.__code__
+                    globals_dict = actual_func.__globals__
+                    name = actual_func.__name__
+                    defaults = actual_func.__defaults__
+                    kwdefaults = actual_func.__kwdefaults__
+                    closure = actual_func.__closure__
+                else:
+                    code = cls.__code__
+                    globals_dict = cls.__globals__
+                    name = cls.__name__
+                    defaults = cls.__defaults__
+                    kwdefaults = cls.__kwdefaults__
+                    closure = cls.__closure__
+
+                new_func = types.FunctionType(
+                    code,
+                    globals_dict,
+                    name,
+                    defaults,
+                    closure,
+                )
+                if kwdefaults is not None:
+                    new_func.__kwdefaults__ = kwdefaults
+                new_func.__dict__.update(cls.__dict__)
+                new_func.__module__ = cls.__module__
+                new_func.__qualname__ = getattr(cls, "__qualname__", cls.__name__)
+                new_func.__annotations__ = processed_hints
+
+                if inspect.ismethod(cls):
+                    new_method = types.MethodType(new_func, cls.__self__)
+                    return TypeAdapter(new_method)
+                else:
+                    return TypeAdapter(new_func)
+
+    return TypeAdapter(cls)
+
+
+def _clean_schema(
+    schema: dict[str, Any],
+    *,
+    prune_titles: bool = True,
+    prune_additional_properties: bool = True,
+) -> dict[str, Any]:
+    """
+    Clean up a JSON schema by removing titles and additionalProperties: false.
+    This is applied recursively to all nested schemas.
+    """
+
+    def _traverse(node: Any) -> Any:
+        if isinstance(node, dict):
+            new_node = {}
+            for key, value in node.items():
+                # Skip titles if pruning
+                if prune_titles and key == "title":
+                    continue
+                # Skip additionalProperties: false if pruning
+                if (
+                    prune_additional_properties
+                    and key == "additionalProperties"
+                    and value is False
+                ):
+                    continue
+                new_node[key] = _traverse(value)
+            return new_node
+        elif isinstance(node, list):
+            return [_traverse(item) for item in node]
+        else:
+            return node
+
+    return _traverse(schema)
+
+
+def _get_type_hint_string(type_annotation: Any) -> str:
+    """
+    Get a readable string representation of a type annotation.
+    Handles generic types, unions, etc.
+    """
+    import re
+
+    # Handle None type
+    if type_annotation is type(None):
+        return "None"
+
+    # For generic types, get_origin and get_args give us the components
+    origin = get_origin(type_annotation)
+    args = get_args(type_annotation)
+
+    if origin is not None and args:
+        # Get the origin name (list, dict, etc.)
+        if hasattr(origin, "__name__"):
+            origin_name = origin.__name__
+        else:
+            origin_name = str(origin).replace("typing.", "")
+
+        # Recursively get arg strings
+        arg_strs = [_get_type_hint_string(arg) for arg in args]
+
+        # Handle Union types (including | syntax)
+        if origin_name in ("Union", "UnionType"):
+            return " | ".join(arg_strs)
+
+        return f"{origin_name}[{', '.join(arg_strs)}]"
+
+    # Try to get __name__ for simple types (int, str, custom classes)
+    if hasattr(type_annotation, "__name__"):
+        return type_annotation.__name__
+
+    # For anything else, use string representation and clean it up
+    type_str = str(type_annotation)
+
+    # Remove module prefixes like '__main__.', 'mymodule.', etc.
+    type_str = re.sub(r"\b\w+\.", "", type_str)
+    # Remove 'typing.' prefix (in case it's still there)
+    type_str = type_str.replace("typing.", "")
+    # Remove 'typing_extensions.' prefix
+    type_str = type_str.replace("typing_extensions.", "")
+
+    return type_str
+
+
+def _format_output_schema_for_description(
+    return_type: Any,
+    output_schema: dict[str, Any] | None,
+) -> str | None:
+    """
+    Format output schema information for inclusion in tool description.
+
+    Returns a string like:
+        "Returns: list[SearchResult]
+
+        SearchResult: {"properties": {...}, "type": "object"}"
+
+    Or None if there's no meaningful output schema to show.
+    """
+    import json
+
+    if return_type is None or return_type is inspect.Parameter.empty:
+        return None
+
+    # Get the type hint string
+    type_hint = _get_type_hint_string(return_type)
+
+    # Start with the return type
+    parts = [f"Returns: {type_hint}"]
+
+    # If there are $defs, include them
+    if output_schema and "$defs" in output_schema:
+        defs = output_schema["$defs"]
+        for def_name, def_schema in defs.items():
+            # Format the schema compactly (single line)
+            schema_str = json.dumps(def_schema, separators=(",", ":"))
+            parts.append(f"{def_name}: {schema_str}")
+
+    return "\n\n".join(parts)
+
+
+def _is_typeddict(cls: Any) -> bool:
+    """Check if a class is a TypedDict."""
+    return (
+        isinstance(cls, type)
+        and hasattr(cls, "__annotations__")
+        and hasattr(cls, "__total__")
+    )
+
+
+def _normalize_parameters(
+    params: Any,
+) -> tuple[dict[str, Any], list[str], dict[str, Any] | None]:
+    """
+    Normalize various parameter input formats to JSON schema components.
+
+    Accepts:
+        - None -> empty schema
+        - dict with "type" keys (already JSON schema) -> pass through
+        - dict mapping names to Python types {name: str, age: int}
+        - dict mapping names to (type, extras) tuples {name: (str, {"description": "..."})}
+        - Pydantic BaseModel class
+        - TypedDict class
+
+    Returns:
+        (properties, required, definitions)
+    """
+
+    def _schema_from_type(annotation: Any) -> dict[str, Any]:
+        """
+        Prefer TypeAdapter-based schemas (handles Union/Optional, Annotated, etc).
+        Fall back to the legacy mapper if TypeAdapter cannot handle the type.
+        """
+        try:
+            ta = TypeAdapter(annotation)
+            return _clean_schema(ta.json_schema())
+        except Exception:
+            return _python_type_to_json_schema(annotation)
+
+    if params is None:
+        return {}, [], None
+
+    # Pydantic model
+    if isinstance(params, type) and issubclass(params, BaseModel):
+        schema = params.model_json_schema()
+        schema = _clean_schema(schema)
+        properties = schema.get("properties", {})
+        required = schema.get("required", [])
+        definitions = schema.get("$defs")
+        return properties, required, definitions
+
+    # TypedDict
+    if _is_typeddict(params):
+        try:
+            ta = TypeAdapter(params)
+            schema = _clean_schema(ta.json_schema())
+            properties = schema.get("properties", {})
+            required = schema.get("required", [])
+            definitions = schema.get("$defs")
+            return properties, required, definitions
+        except Exception:
+            # Fall back to manual extraction
+            hints = get_type_hints(params)
+            properties = {}
+            required = []
+            for field_name, field_type in hints.items():
+                properties[field_name] = _python_type_to_json_schema(field_type)
+                required.append(field_name)
+            return properties, required, None
+
+    # Must be a dict at this point
+    if not isinstance(params, dict):
+        raise TypeError(
+            f"parameters must be a dict, Pydantic model, or TypedDict, "
+            f"got {type(params).__name__}"
+        )
+
+    # Check if it's already a JSON schema (has "type" keys in values)
+    # vs a simple {name: type} mapping
+    if params and all(
+        isinstance(v, dict) and "type" in v for v in params.values() if v is not None
+    ):
+        # Already JSON schema format - extract required from presence of "optional" key
+        required = [
+            name for name, schema in params.items() if not schema.get("optional", False)
+        ]
+        # Remove "optional" keys as they're not valid JSON schema
+        cleaned = {}
+        for name, schema in params.items():
+            cleaned[name] = {k: v for k, v in schema.items() if k != "optional"}
+        return cleaned, required, None
+
+    # Simple {name: type} or {name: (type, extras)} mapping
+    properties = {}
+    required = []
+
+    for param_name, param_spec in params.items():
+        # Tuple of (type, extras)
+        if isinstance(param_spec, tuple) and len(param_spec) == 2:
+            param_type, extras = param_spec
+            if isinstance(extras, dict):
+                schema = _schema_from_type(param_type)
+                schema.update(extras)
+                # Remove "optional" key as it's not valid JSON schema
+                is_optional = schema.pop("optional", False)
+                properties[param_name] = schema
+                if not is_optional:
+                    required.append(param_name)
+                continue
+
+        # Python type (int, str, list[str], etc.)
+        if isinstance(param_spec, type) or get_origin(param_spec) is not None:
+            properties[param_name] = _schema_from_type(param_spec)
+            required.append(param_name)
+            continue
+
+        # Already a JSON schema dict
+        if isinstance(param_spec, dict):
+            schema = param_spec.copy()
+            is_optional = schema.pop("optional", False)
+            properties[param_name] = schema
+            if not is_optional:
+                required.append(param_name)
+            continue
+
+        # Unknown - try to convert
+        properties[param_name] = _schema_from_type(param_spec)
+        required.append(param_name)
+
+    return properties, required, None
+
+
+def _python_type_to_json_schema(python_type: Any) -> dict[str, Any]:
     """
     Convert Python type annotations to JSON Schema.
     Handles: primitives, Optional, Literal, list[T], dict[str, T], Union.
@@ -42,7 +364,7 @@ def _python_type_to_json_schema_enhanced(python_type: Any) -> dict[str, Any]:
     # Handle list[T]
     if origin is list:
         if args:
-            items_schema = _python_type_to_json_schema_enhanced(args[0])
+            items_schema = _python_type_to_json_schema(args[0])
             return {"type": "array", "items": items_schema}
         return {"type": "array"}
 
@@ -50,7 +372,7 @@ def _python_type_to_json_schema_enhanced(python_type: Any) -> dict[str, Any]:
     if origin is dict:
         if len(args) >= 2:
             # For dict[str, T], we can set additionalProperties
-            value_schema = _python_type_to_json_schema_enhanced(args[1])
+            value_schema = _python_type_to_json_schema(args[1])
             return {"type": "object", "additionalProperties": value_schema}
         return {"type": "object"}
 
@@ -72,145 +394,6 @@ def _python_type_to_json_schema_enhanced(python_type: Any) -> dict[str, Any]:
         return {"type": "string"}
 
 
-class ToolParams:
-    """
-    Helper class for constructing tool parameters more easily.
-
-    Usage:
-        # Simple constructor with Python types
-        params = ToolParams({"city": str, "age": int})
-
-        # With extras (description, enum, etc)
-        params = ToolParams({
-            "operation": (str, {"enum": ["add", "sub"], "description": "Math operation"}),
-            "value": (int, {"description": "The value"})
-        })
-
-        # From Pydantic model
-        params = ToolParams.from_pydantic(MyModel)
-
-        # From TypedDict
-        params = ToolParams.from_typed_dict(MyTypedDict)
-
-        # From existing JSON Schema
-        params = ToolParams.from_json_schema(schema_dict, required=["field1"])
-    """
-
-    def __init__(self, spec: dict[str, Any]):
-        """
-        Create ToolParams from a dict mapping parameter names to types or (type, extras) tuples.
-
-        Args:
-            spec: Dict where values can be:
-                - A Python type (str, int, list[str], etc.)
-                - A tuple of (type, extras_dict) for additional JSON Schema properties
-                - An already-formed JSON Schema dict (passed through as-is)
-        """
-        self.parameters: dict[str, Any] = {}
-        self.required: list[str] = []
-
-        for param_name, param_spec in spec.items():
-            # If it's a tuple, extract (type, extras)
-            if isinstance(param_spec, tuple):
-                param_type, extras = param_spec
-                schema = _python_type_to_json_schema_enhanced(param_type)
-                schema.update(extras)
-                self.parameters[param_name] = schema
-                # Mark as required unless explicitly marked as optional
-                if extras.get("optional") is not True:
-                    self.required.append(param_name)
-            # If it's already a dict with "type" key, use as-is
-            elif isinstance(param_spec, dict) and "type" in param_spec:
-                self.parameters[param_name] = param_spec
-                # Assume required unless marked optional
-                if param_spec.get("optional") is not True:
-                    self.required.append(param_name)
-            # Otherwise treat as a Python type
-            else:
-                self.parameters[param_name] = _python_type_to_json_schema_enhanced(
-                    param_spec
-                )
-                self.required.append(param_name)
-
-    @classmethod
-    def from_pydantic(cls, model: Type[BaseModel]) -> "ToolParams":
-        """
-        Create ToolParams from a Pydantic model.
-
-        Args:
-            model: A Pydantic BaseModel class
-        """
-        # Get the JSON schema from Pydantic
-        schema = model.model_json_schema()
-        properties = schema.get("properties", {})
-        required = schema.get("required", [])
-
-        return cls.from_json_schema(properties, required)
-
-    @classmethod
-    def from_typed_dict(cls, typed_dict: Type) -> "ToolParams":
-        """
-        Create ToolParams from a TypedDict.
-
-        Args:
-            typed_dict: A TypedDict class
-        """
-        hints = get_type_hints(typed_dict)
-
-        # TypedDict doesn't have a built-in way to mark optional fields,
-        # but we can check for Optional in the type hints
-        params = {}
-        required = []
-
-        for field_name, field_type in hints.items():
-            # Check if it's Optional (Union with None)
-            origin = get_origin(field_type)
-            # args = get_args(field_type)
-
-            is_optional = False
-            actual_type = field_type
-
-            # Check for Union types (including Optional[T] which is Union[T, None])
-            if origin is type(None):
-                is_optional = True
-                actual_type = type(None)
-
-            # For now, treat all TypedDict fields as required unless they're explicitly Optional
-            schema = _python_type_to_json_schema_enhanced(actual_type)
-            params[field_name] = schema
-
-            if not is_optional:
-                required.append(field_name)
-
-        instance = cls.__new__(cls)
-        instance.parameters = params
-        instance.required = required
-        return instance
-
-    @classmethod
-    def from_json_schema(
-        cls, properties: dict[str, Any], required: list[str] | None = None
-    ) -> "ToolParams":
-        """
-        Create ToolParams from an existing JSON Schema properties dict.
-
-        Args:
-            properties: The "properties" section of a JSON Schema
-            required: List of required field names
-        """
-        instance = cls.__new__(cls)
-        instance.parameters = properties
-        instance.required = required or []
-        return instance
-
-    def to_dict(self) -> dict[str, Any]:
-        """
-        Convert to a dict with 'parameters' and 'required' keys.
-        Useful for unpacking into Tool constructor.
-        """
-        return {"parameters": self.parameters, "required": self.required}
-
-
 async def _load_all_mcp_tools(client: Client) -> list["Tool"]:
     metas: list[MCPTool] = await client.list_tools()
 
@@ -259,13 +442,44 @@ async def _load_all_mcp_tools(client: Client) -> list["Tool"]:
 class Tool(BaseModel):
     """
     Provider‑agnostic tool definition with no extra nesting.
+
+    The `parameters` argument accepts multiple formats:
+        - dict with JSON schema: {"query": {"type": "string"}}
+        - dict with Python types: {"query": str, "limit": int}
+        - dict with (type, extras) tuples: {"query": (str, {"description": "..."})}
+        - Pydantic BaseModel class
+        - TypedDict class
+
+    Examples:
+        # From JSON schema (traditional)
+        Tool(name="search", parameters={"query": {"type": "string"}}, ...)
+
+        # From Python types (simple)
+        Tool(name="search", parameters={"query": str, "limit": int}, ...)
+
+        # From Pydantic model
+        class SearchParams(BaseModel):
+            query: str
+            limit: int = 10
+        Tool(name="search", parameters=SearchParams, ...)
+
+        # From TypedDict
+        class SearchParams(TypedDict):
+            query: str
+            limit: NotRequired[int]
+        Tool(name="search", parameters=SearchParams, ...)
+
+        # From function (recommended for most cases)
+        Tool.from_function(my_search_function)
     """
 
+    model_config = {"arbitrary_types_allowed": True}
+
     name: str
     description: str | None = None
     parameters: dict[str, Any] | None = None
     required: list[str] = Field(default_factory=list)
-    additionalProperties: bool | None = None  # only
+    additionalProperties: bool | None = None
     # if desired, can provide a callable to run the tool
     run: Callable | None = None
     # for built-in tools that don't require schema
@@ -274,6 +488,25 @@ class Tool(BaseModel):
     built_in_args: dict[str, Any] = Field(default_factory=dict)
     # JSON Schema definitions (for $ref support)
     definitions: dict[str, Any] | None = None
+    # Output schema (extracted from return type annotation)
+    output_schema: dict[str, Any] | None = None
+    # TypeAdapter for output validation (not serialized, stored as private attr)
+    _output_type_adapter: TypeAdapter | None = None
+
+    def __init__(self, **data):
+        # Normalize parameters before passing to Pydantic
+        raw_params = data.get("parameters")
+        if raw_params is not None:
+            properties, required_fields, definitions = _normalize_parameters(raw_params)
+            data["parameters"] = properties
+            # Only set required if not explicitly provided (check for key presence, not truthiness)
+            if "required" not in data:
+                data["required"] = required_fields
+            # Only set definitions if not explicitly provided and we have new ones
+            if definitions and "definitions" not in data:
+                data["definitions"] = definitions
+
+        super().__init__(**data)
 
     @field_validator("name")
     @classmethod
@@ -285,28 +518,41 @@ class Tool(BaseModel):
             )
         return v
 
-    @field_validator("parameters", mode="before")
-    @classmethod
-    def validate_parameters(cls, v: Any) -> dict[str, Any] | None:
-        """Accept ToolParams objects and convert to dict for backwards compatibility."""
-        if isinstance(v, ToolParams):
-            return v.parameters
-        return v
-
-    def model_post_init(self, __context: Any) -> None:
-        """
-        After validation, if parameters came from ToolParams, also update required list.
-        This is called by Pydantic after __init__.
-        """
-        # This is a bit tricky - we need to capture the required list from ToolParams
-        # Since Pydantic has already converted it in the validator, we can't access it here
-        # Instead, we'll handle this differently in the convenience constructors
-        pass
-
     def _is_async(self) -> bool:
         return inspect.iscoroutinefunction(self.run)
 
-    def call(self, **kwargs) -> str | list[ToolResultPart]:
+    def _validate_output(self, result: Any) -> Any:
+        """Validate output against output_schema if TypeAdapter is available."""
+        if self._output_type_adapter is None:
+            raise ValueError(
+                "Cannot validate output: no output type adapter available. "
+                "Make sure the tool was created with from_function() and has a return type annotation."
+            )
+        # This will raise ValidationError if result doesn't match the schema
+        return self._output_type_adapter.validate_python(result)
+
+    def call(
+        self, *, validate_output: bool = False, **kwargs
+    ) -> str | list[ToolResultPart]:
+        """
+        Call the tool with the given arguments.
+
+        Args:
+            validate_output: If True, validate the return value against the
+                output schema. Raises ValidationError if validation fails.
+                Requires the tool to have been created with from_function()
+                and have a return type annotation.
+            **kwargs: Arguments to pass to the tool function.
+
+        Returns:
+            The result of the tool function.
+
+        Raises:
+            ValueError: If no run function is provided or validation is requested
+                but no output type adapter is available.
+            pydantic.ValidationError: If validate_output=True and the result
+                doesn't match the output schema.
+        """
         if self.run is None:
             raise ValueError("No run function provided")
 
@@ -317,32 +563,96 @@ class Tool(BaseModel):
                 assert loop
             except RuntimeError:
                 # no loop → safe to block
-                return asyncio.run(coro)
+                result = asyncio.run(coro)
             else:
                 # Loop is running → execute coroutine in a worker thread
                 def _runner():
                     return asyncio.run(coro)
 
                 with ThreadPoolExecutor(max_workers=1) as executor:
-                    return executor.submit(_runner).result()
+                    result = executor.submit(_runner).result()
         else:
             # plain function
-            return self.run(**kwargs)
+            result = self.run(**kwargs)
+
+        if validate_output:
+            self._validate_output(result)
 
-    async def acall(self, **kwargs) -> str | list[ToolResultPart]:
+        return result
+
+    async def acall(
+        self, *, validate_output: bool = False, **kwargs
+    ) -> str | list[ToolResultPart]:
+        """
+        Async version of call().
+
+        Args:
+            validate_output: If True, validate the return value against the
+                output schema. Raises ValidationError if validation fails.
+            **kwargs: Arguments to pass to the tool function.
+
+        Returns:
+            The result of the tool function.
+        """
         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]
+            result = 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
+            result = await loop.run_in_executor(None, lambda: self.run(**kwargs))  # type: ignore
+
+        if validate_output:
+            self._validate_output(result)
+
+        return result
 
     @classmethod
-    def from_function(cls, func: Callable) -> "Tool":
-        """Create a Tool from a function using introspection."""
+    def from_function(
+        cls,
+        func: Callable,
+        *,
+        include_output_schema_in_description: bool = False,
+    ) -> "Tool":
+        """
+        Create a Tool from a function using introspection.
+
+        Uses Pydantic's TypeAdapter for robust schema generation, supporting:
+        - All Python types (primitives, generics, unions, Literal, etc.)
+        - Pydantic models and TypedDict as parameter types
+        - Annotated[T, Field(description="...")] for parameter descriptions
+        - Annotated[T, "description"] shorthand for descriptions
+        - Complex nested types with proper $defs/$ref handling
+        - Output schema extraction from return type annotation
+
+        Args:
+            func: The function to create a tool from.
+            include_output_schema_in_description: If True, append the return type
+                and any complex type definitions to the tool description. This can
+                help the model understand what the tool returns. Default is False.
+
+        Example:
+            def search(
+                query: Annotated[str, Field(description="Search query")],
+                limit: int = 10,
+                filters: dict[str, str] | None = None,
+            ) -> list[dict]:
+                '''Search the database.'''
+                ...
+
+            tool = Tool.from_function(search)
+            # tool.output_schema contains schema for list[dict]
+            # tool.call(query="test", validate_output=True) validates return value
+
+            # With output schema in description:
+            tool = Tool.from_function(search, include_output_schema_in_description=True)
+            # Description becomes:
+            # "Search the database.
+            #
+            # Returns: list[dict]"
+        """
         # Get function name
         name = func.__name__
 
@@ -350,38 +660,62 @@ class Tool(BaseModel):
         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
+        # Use TypeAdapter for robust schema generation
+        type_adapter = _get_cached_typeadapter(func)
+        schema = type_adapter.json_schema()
 
-            # Get type hint
-            param_type = type_hints.get(param_name, str)
+        # Clean up the schema (remove titles, additionalProperties: false)
+        schema = _clean_schema(schema)
 
-            # Convert Python types to JSON Schema types
-            json_type = _python_type_to_json_schema_enhanced(param_type)
+        # Extract parameters and required from the schema
+        parameters = schema.get("properties", {})
+        required = schema.get("required", [])
+        definitions = schema.get("$defs")
 
-            parameters[param_name] = json_type
+        # Extract output schema from return type annotation
+        output_schema = None
+        output_type_adapter = None
+        sig = inspect.signature(func)
+        return_type = sig.return_annotation
 
-            # Add to required if no default value
-            if param.default is param.empty:
-                required.append(param_name)
+        if return_type is not inspect.Parameter.empty:
+            try:
+                # Resolve string annotations if needed
+                if isinstance(return_type, str):
+                    hints = get_type_hints(func)
+                    return_type = hints.get("return", return_type)
+
+                # Create TypeAdapter for output validation
+                output_type_adapter = TypeAdapter(return_type)
+                output_schema = _clean_schema(output_type_adapter.json_schema())
+            except Exception:
+                # If we can't create a schema for the return type, that's fine
+                # (e.g., for non-serializable types like custom classes)
+                pass
+
+        # Optionally append output schema info to description
+        if (
+            include_output_schema_in_description
+            and return_type is not inspect.Parameter.empty
+        ):
+            output_info = _format_output_schema_for_description(
+                return_type, output_schema
+            )
+            if output_info:
+                description = f"{description}\n\n{output_info}"
 
-        return cls(
+        tool = cls(
             name=name,
             description=description,
             parameters=parameters,
             required=required,
+            definitions=definitions,
+            output_schema=output_schema,
             run=func,
         )
+        # Store the TypeAdapter for runtime validation (not serialized)
+        tool._output_type_adapter = output_type_adapter
+        return tool
 
     @classmethod
     async def from_mcp_config(
@@ -433,119 +767,6 @@ class Tool(BaseModel):
                 return t
         raise ValueError(f"Tool '{tool_name}' not found on that server")
 
-    @classmethod
-    def from_params(
-        cls,
-        name: str,
-        params: ToolParams,
-        *,
-        description: str | None = None,
-        run: Callable | None = None,
-        **kwargs,
-    ) -> "Tool":
-        """
-        Create a Tool from a ToolParams object.
-
-        Args:
-            name: Tool name
-            params: ToolParams object defining the parameter schema
-            description: Optional description
-            run: Optional callable to execute the tool
-            **kwargs: Additional Tool arguments
-
-        Example:
-            params = ToolParams({"city": str, "age": int})
-            tool = Tool.from_params("get_user", params, run=my_function)
-        """
-        return cls(
-            name=name,
-            description=description,
-            parameters=params.parameters,
-            required=params.required,
-            run=run,
-            **kwargs,
-        )
-
-    @classmethod
-    def from_pydantic(
-        cls,
-        name: str,
-        model: Type[BaseModel],
-        *,
-        description: str | None = None,
-        run: Callable | None = None,
-        **kwargs,
-    ) -> "Tool":
-        """
-        Create a Tool from a Pydantic model.
-
-        Args:
-            name: Tool name
-            model: Pydantic BaseModel class
-            description: Optional description (defaults to model docstring)
-            run: Optional callable to execute the tool
-            **kwargs: Additional Tool arguments
-
-        Example:
-            class UserQuery(BaseModel):
-                city: str
-                age: int
-
-            tool = Tool.from_pydantic("get_user", UserQuery, run=my_function)
-        """
-        params = ToolParams.from_pydantic(model)
-
-        # Use model docstring as default description if not provided
-        if description is None and model.__doc__:
-            description = model.__doc__.strip()
-
-        return cls(
-            name=name,
-            description=description,
-            parameters=params.parameters,
-            required=params.required,
-            run=run,
-            **kwargs,
-        )
-
-    @classmethod
-    def from_typed_dict(
-        cls,
-        name: str,
-        typed_dict: Type,
-        *,
-        description: str | None = None,
-        run: Callable | None = None,
-        **kwargs,
-    ) -> "Tool":
-        """
-        Create a Tool from a TypedDict.
-
-        Args:
-            name: Tool name
-            typed_dict: TypedDict class
-            description: Optional description
-            run: Optional callable to execute the tool
-            **kwargs: Additional Tool arguments
-
-        Example:
-            class UserQuery(TypedDict):
-                city: str
-                age: int
-
-            tool = Tool.from_typed_dict("get_user", UserQuery, run=my_function)
-        """
-        params = ToolParams.from_typed_dict(typed_dict)
-
-        return cls(
-            name=name,
-            description=description,
-            parameters=params.parameters,
-            required=params.required,
-            run=run,
-            **kwargs,
-        )
-
     @staticmethod
     def _tool_from_meta(meta: dict[str, Any], runner) -> "Tool":
         props = meta["inputSchema"].get("properties", {})
@@ -560,14 +781,6 @@ class Tool(BaseModel):
             run=runner,
         )
 
-    @staticmethod
-    def _python_type_to_json_schema(python_type) -> dict[str, Any]:
-        """
-        Convert Python type to JSON Schema type definition.
-        Now delegates to enhanced version for better type support.
-        """
-        return _python_type_to_json_schema_enhanced(python_type)
-
     def _is_strict_mode_compatible(self) -> bool:
         """
         Check if this tool's schema is compatible with OpenAI strict mode.
@@ -892,3 +1105,7 @@ class MCPServer(BaseModel):
             tools: list[Tool] = await Tool.from_mcp(self.name, url=self.url)
             self._tools = tools
             return tools
+
+
+# Note: prefab submodule is available via lm_deluge.tool.prefab
+# but not auto-imported here to avoid circular imports