predikit 0.5.2__tar.gz → 0.6.1__tar.gz

{predikit-0.5.2 → predikit-0.6.1}/.claude/settings.local.json

@@ -27,7 +27,19 @@
       "Bash(git stash *)",
       "Bash(./.venv/Scripts/python.exe -m pytest -q)",
       "Bash(./.venv/Scripts/python.exe -c \"import numpy; print\\(numpy.__version__\\); print\\(numpy.__file__\\)\")",
-      "Bash(./.venv/Scripts/python.exe -m mypy --version)"
+      "Bash(./.venv/Scripts/python.exe -m mypy --version)",
+      "Bash(gh release *)",
+      "Bash(python -c \"import mcp; print\\('mcp', mcp.__version__ if hasattr\\(mcp,'__version__'\\) else 'installed'\\)\")",
+      "Bash(python -c \"import snowflake.ml; print\\('snowflake-ml installed'\\)\")",
+      "Bash(python -m pytest -q --cov=src/predikit --cov-report=term-missing)",
+      "Bash(py -0p)",
+      "Bash(where python *)",
+      "Bash(.venv/Scripts/python.exe -m pytest -q --cov=src/predikit --cov-report=term-missing)",
+      "Bash(command -v uv)",
+      "Bash(.venv/Scripts/python.exe -m pip download 'mcp>=1.28,<2' -d __TRACKED_VAR__/mcpdl --no-deps -q)",
+      "Bash(.venv/Scripts/python.exe -m pip show twine)",
+      "Bash(.venv/Scripts/python.exe -m pip install -q -U twine)",
+      "Bash(.venv/Scripts/python.exe -m twine check dist/*0.6.1*)"
     ],
     "additionalDirectories": [
       "C:\\AI\\predikit"

{predikit-0.5.2 → predikit-0.6.1}/.github/workflows/test.yml

@@ -40,7 +40,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.10", "3.11", "3.12"]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
 
     steps:
       - uses: actions/checkout@v4

{predikit-0.5.2 → predikit-0.6.1}/CHANGELOG.md

@@ -6,6 +6,29 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 
+## [0.6.1] - 2026-08-15
+
+### Fixed
+- MCP tools now advertise an `outputSchema` and return `structuredContent`. The generated callable carried no return annotation, so FastMCP emitted `outputSchema: null` and every result came back as unstructured text. Output fields are named from the tool's `output_name` / `output_description`, and a `collect` ensemble declares each member's output.
+- Low-confidence results keep their `_confidence` and `_low_confidence` keys when served over MCP. The output model allows extra keys; a strict one validates them away silently.
+- `predikit serve` no longer disguises unrelated failures as a bad registry target. Module import and attribute lookup are handled separately, and errors raised while building or running the server propagate with their own traceback instead of being reported as `Could not load registry target`.
+- `coerce_value()` converts `True` / `False` to `1` / `0` for `int` fields. `isinstance(True, int)` is true in Python, so bools previously passed through unconverted.
+
+### Added
+- `--host` and `--port` options on `predikit serve`, plus matching `host` / `port` arguments on `create_mcp_server()`. The `streamable-http` transport was previously stuck on the SDK default of `127.0.0.1:8000`.
+- `ToolRegistry.items()`, `.names()`, `__iter__`, and `__len__` as the public way to enumerate a registry. `create_mcp_server()` used the private `_tools` / `_ensembles` attributes; `to_openai()` and `to_langchain()` now share the same accessor.
+- Python 3.13 in the CI matrix and the package classifiers.
+
+### Changed
+- `mcp` is now a dev dependency, so the MCP integration is tested against the real SDK. The previous tests substituted a fake `FastMCP` and reported full coverage of `mcp.py` while never exercising the SDK — which is how the missing output schema shipped.
+- Test coverage for `predikit serve`, which previously had none.
+
+## [0.6.0] - 2026-08-03
+
+### Added
+- MCP server integration via `create_mcp_server()` and `predikit serve`.
+- Optional `mcp` dependency for exposing `ToolRegistry` tools to MCP-compatible clients.
+
 ## [0.5.2] - 2026-08-01
 
 ### Fixed

{predikit-0.5.2 → predikit-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: predikit
-Version: 0.5.2
+Version: 0.6.1
 Summary: Wrap any trained sklearn/XGBoost model as an LLM-callable tool: auto-generated JSON schemas, Pydantic I/O, OpenAI & LangChain ready, zero boilerplate.
 Project-URL: Homepage, https://github.com/Tejas-TA/predikit
 Project-URL: Repository, https://github.com/Tejas-TA/predikit
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
@@ -33,6 +34,7 @@ Provides-Extra: dev
 Requires-Dist: click>=8.0; extra == 'dev'
 Requires-Dist: joblib>=1.2; extra == 'dev'
 Requires-Dist: langchain-core>=0.1; extra == 'dev'
+Requires-Dist: mcp<2,>=1.28; extra == 'dev'
 Requires-Dist: mlflow>=2.0; extra == 'dev'
 Requires-Dist: mypy>=1.10; extra == 'dev'
 Requires-Dist: pandas>=1.5; extra == 'dev'
@@ -43,6 +45,8 @@ Requires-Dist: ruff>=0.4.0; extra == 'dev'
 Requires-Dist: xgboost>=1.7; extra == 'dev'
 Provides-Extra: langchain
 Requires-Dist: langchain-core>=0.1; extra == 'langchain'
+Provides-Extra: mcp
+Requires-Dist: mcp<2,>=1.28; extra == 'mcp'
 Provides-Extra: mlflow
 Requires-Dist: mlflow>=2.0; extra == 'mlflow'
 Provides-Extra: snowflake
@@ -324,6 +328,20 @@ response = client.chat.completions.create(
 agent = initialize_agent(tools=registry.to_langchain(), ...)
 ```
 
+### MCP server
+
+Expose the same registry to MCP-compatible clients with the optional MCP extra:
+
+```bash
+pip install predikit[mcp]
+predikit serve my_tools:registry
+```
+
+`my_tools:registry` must point to a `ToolRegistry`, or to a zero-argument function
+that returns one. The default transport is `stdio`; use `--transport streamable-http`
+when serving over HTTP. MCP tools use the same Pydantic input validation and model
+execution as direct `invoke()` calls.
+
 ### Bool inputs from an LLM
 
 LLMs sometimes return `"yes"`, `"true"`, or `"1"` for boolean fields. predikit coerces these automatically before Pydantic validation:
@@ -463,7 +481,7 @@ See [`examples/03_orlando_real_estate.py`](examples/03_orlando_real_estate.py) f
 - [ ] HuggingFace / PyTorch / TensorFlow model support
 - [ ] Streaming inference support
 - [ ] OpenAI Assistants API integration
-- [ ] MCP server mode
+- [x] MCP server mode (stdio and Streamable HTTP)
 
 ---
 

{predikit-0.5.2 → predikit-0.6.1}/README.md

@@ -271,6 +271,20 @@ response = client.chat.completions.create(
 agent = initialize_agent(tools=registry.to_langchain(), ...)
 ```
 
+### MCP server
+
+Expose the same registry to MCP-compatible clients with the optional MCP extra:
+
+```bash
+pip install predikit[mcp]
+predikit serve my_tools:registry
+```
+
+`my_tools:registry` must point to a `ToolRegistry`, or to a zero-argument function
+that returns one. The default transport is `stdio`; use `--transport streamable-http`
+when serving over HTTP. MCP tools use the same Pydantic input validation and model
+execution as direct `invoke()` calls.
+
 ### Bool inputs from an LLM
 
 LLMs sometimes return `"yes"`, `"true"`, or `"1"` for boolean fields. predikit coerces these automatically before Pydantic validation:
@@ -410,7 +424,7 @@ See [`examples/03_orlando_real_estate.py`](examples/03_orlando_real_estate.py) f
 - [ ] HuggingFace / PyTorch / TensorFlow model support
 - [ ] Streaming inference support
 - [ ] OpenAI Assistants API integration
-- [ ] MCP server mode
+- [x] MCP server mode (stdio and Streamable HTTP)
 
 ---
 

{predikit-0.5.2 → predikit-0.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "predikit"
-version = "0.5.2"
+version = "0.6.1"
 description = "Wrap any trained sklearn/XGBoost model as an LLM-callable tool: auto-generated JSON schemas, Pydantic I/O, OpenAI & LangChain ready, zero boilerplate."
 readme = "README.md"
 license = {text = "MIT"}
@@ -25,6 +25,7 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
     "Intended Audience :: Developers",
     "Intended Audience :: Science/Research",
@@ -39,6 +40,7 @@ dependencies = [
 
 [project.optional-dependencies]
 langchain = ["langchain-core>=0.1"]
+mcp = ["mcp>=1.28,<2"]
 xgboost = ["xgboost>=1.7"]
 mlflow = ["mlflow>=2.0"]
 snowflake = ["snowflake-ml-python>=1.0"]
@@ -49,6 +51,7 @@ dev = [
     "xgboost>=1.7",
     "langchain-core>=0.1",
     "pandas>=1.5",
+    "mcp>=1.28,<2",
     "mlflow>=2.0",
     "click>=8.0",
     "joblib>=1.2",

{predikit-0.5.2 → predikit-0.6.1}/src/predikit/__init__.py

@@ -1,7 +1,8 @@
 from .ensemble import ModelEnsemble
 from .exceptions import LowConfidenceError
+from .mcp import create_mcp_server
 from .registry import ToolRegistry
 from .tool import ModelTool
 
-__all__ = ["ModelTool", "ToolRegistry", "ModelEnsemble", "LowConfidenceError"]
-__version__ = "0.5.2"
+__all__ = ["ModelTool", "ToolRegistry", "ModelEnsemble", "LowConfidenceError", "create_mcp_server"]
+__version__ = "0.6.1"

{predikit-0.5.2 → predikit-0.6.1}/src/predikit/cli.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import importlib
 import json
 import sys
 from typing import Any
@@ -74,6 +75,59 @@ if _CLICK_AVAILABLE:
         else:
             click.echo("\nOpenAI schema: unavailable (fit model with a named DataFrame to enable)")
 
+    @cli.command()
+    @click.argument("registry_target")
+    @click.option("--name", default="predikit", show_default=True, help="MCP server name.")
+    @click.option(
+        "--transport",
+        type=click.Choice(["stdio", "streamable-http"]),
+        default="stdio",
+        show_default=True,
+        help="MCP transport to run.",
+    )
+    @click.option(
+        "--host", default=None, help="Bind host for HTTP transports. [default: 127.0.0.1]"
+    )
+    @click.option(
+        "--port", type=int, default=None, help="Bind port for HTTP transports. [default: 8000]"
+    )
+    def serve(
+        registry_target: str,
+        name: str,
+        transport: str,
+        host: str | None,
+        port: int | None,
+    ) -> None:
+        """Serve a ToolRegistry from MODULE:ATTRIBUTE over MCP.
+
+        ATTRIBUTE may be a ToolRegistry instance or a zero-argument factory.
+        """
+        if ":" not in registry_target:
+            raise click.ClickException("REGISTRY_TARGET must use the form MODULE:ATTRIBUTE")
+        module_name, attribute_name = registry_target.split(":", 1)
+
+        # Keep this block narrow: it resolves the target only. Errors raised while
+        # building or running the server must surface with their own traceback
+        # rather than be reported as a bad registry target.
+        try:
+            module = importlib.import_module(module_name)
+        except ImportError as err:
+            raise click.ClickException(f"Could not import module '{module_name}': {err}") from err
+        try:
+            registry = getattr(module, attribute_name)
+        except AttributeError as err:
+            raise click.ClickException(
+                f"Module '{module_name}' has no attribute '{attribute_name}'"
+            ) from err
+
+        if callable(registry):
+            registry = registry()
+
+        from .mcp import create_mcp_server
+
+        server = create_mcp_server(registry, name=name, host=host, port=port)
+        server.run(transport=transport)
+
 else:
 
     def cli() -> None:  # type: ignore[misc]

{predikit-0.5.2 → predikit-0.6.1}/src/predikit/coerce.py

@@ -8,6 +8,10 @@ _BOOL_FALSE = {"false", "0", "no", "off"}
 
 def coerce_value(value: Any, target_type: type) -> Any:
     """Coerce a single value to target_type with LLM-friendly string handling."""
+    if target_type is int and isinstance(value, bool):
+        # isinstance(True, int) is True, so bools would otherwise pass through unconverted.
+        return int(value)
+
     if isinstance(value, target_type):
         return value
 

predikit-0.6.1/src/predikit/mcp.py

@@ -0,0 +1,115 @@
+"""MCP server integration for predikit tools."""
+
+from __future__ import annotations
+
+import inspect
+from typing import Any, cast
+
+from pydantic import ConfigDict, Field, create_model
+
+from .registry import ToolRegistry
+
+
+def create_mcp_server(
+    registry: ToolRegistry,
+    name: str = "predikit",
+    host: str | None = None,
+    port: int | None = None,
+) -> Any:
+    """Create an MCP server exposing every tool in ``registry``.
+
+    The MCP dependency is optional. Install it with ``pip install predikit[mcp]``.
+    The returned server uses the SDK's standard transports, including ``stdio``.
+
+    ``host`` and ``port`` configure the HTTP transports; leave them unset to keep
+    the MCP SDK defaults (``127.0.0.1:8000``).
+    """
+    try:
+        from mcp.server.fastmcp import FastMCP
+    except ImportError as err:
+        raise ImportError(
+            "The MCP integration requires the optional dependency. "
+            "Install it with: pip install predikit[mcp]"
+        ) from err
+
+    settings: dict[str, Any] = {"json_response": True}
+    if host is not None:
+        settings["host"] = host
+    if port is not None:
+        settings["port"] = port
+
+    server = FastMCP(name, **settings)
+    for tool in registry.items():
+        server.add_tool(
+            _make_mcp_callable(tool),
+            name=tool.name,
+            description=tool.description,
+        )
+    return server
+
+
+def _output_fields(tool: Any) -> list[tuple[str, str]]:
+    """Return the (name, description) pairs a tool's result dict is keyed by."""
+    tools = getattr(tool, "tools", None)
+    if tools is not None and getattr(tool, "strategy", None) == "collect":
+        # A collect ensemble merges every member's output into one dict.
+        return [(t.output_name, t.output_description) for t in tools]
+    return [(tool.output_name, tool.output_description)]
+
+
+def _make_output_model(tool: Any) -> Any:
+    """Build the return annotation used to advertise a tool's output schema.
+
+    ``extra="allow"`` matters: it keeps the ``_confidence`` / ``_low_confidence``
+    keys that a low-confidence result carries. A model without it validates them
+    away, so MCP clients would silently lose them.
+    """
+    fields = _output_fields(tool)
+    if not all(name.isidentifier() for name, _ in fields):
+        # Output names are user-supplied; fall back to a permissive mapping.
+        return dict[str, Any]
+    definitions: dict[str, Any] = {
+        name: (Any, Field(..., description=desc)) for name, desc in fields
+    }
+    return create_model(
+        f"{tool.name}_output",
+        __config__=ConfigDict(extra="allow"),
+        **definitions,
+    )
+
+
+def _make_mcp_callable(tool: Any) -> Any:
+    """Build a callable whose signature mirrors a tool's Pydantic input model."""
+
+    async def invoke(**kwargs: Any) -> dict:
+        return cast(dict, await tool.ainvoke(kwargs))
+
+    parameters = []
+    annotations: dict[str, Any] = {}
+    for name, field in tool.input_schema.model_fields.items():
+        annotation = field.annotation if field.annotation is not None else Any
+        annotations[name] = annotation
+        default = (
+            inspect.Parameter.empty
+            if field.is_required()
+            else field.get_default(call_default_factory=True)
+        )
+        parameters.append(
+            inspect.Parameter(
+                name,
+                inspect.Parameter.KEYWORD_ONLY,
+                annotation=annotation,
+                default=default,
+            )
+        )
+    # FastMCP derives outputSchema from the return annotation. A bare ``dict`` is
+    # not serializable for structured output, so it must be a concrete model.
+    output_model = _make_output_model(tool)
+    annotations["return"] = output_model
+    invoke.__signature__ = inspect.Signature(  # type: ignore[attr-defined]
+        parameters, return_annotation=output_model
+    )
+    invoke.__annotations__ = annotations
+    invoke.__name__ = tool.name
+    invoke.__doc__ = tool.description
+    return invoke

{predikit-0.5.2 → predikit-0.6.1}/src/predikit/registry.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Iterator
+
 from .ensemble import ModelEnsemble
 from .tool import ModelTool
 
@@ -26,15 +28,25 @@ class ToolRegistry:
             return self._tools[name]
         if name in self._ensembles:
             return self._ensembles[name]
-        available = list(self._tools) + list(self._ensembles)
+        available = self.names()
         raise KeyError(f"No tool or ensemble named '{name}'. Available: {available}")
 
+    def items(self) -> list[RegistryItem]:
+        """Return every tool followed by every ensemble, in registration order."""
+        return list(self._tools.values()) + list(self._ensembles.values())
+
+    def names(self) -> list[str]:
+        """Return the name of every registered tool and ensemble."""
+        return [item.name for item in self.items()]
+
+    def __iter__(self) -> Iterator[RegistryItem]:
+        return iter(self.items())
+
+    def __len__(self) -> int:
+        return len(self._tools) + len(self._ensembles)
+
     def to_openai(self) -> list[dict]:
-        return [t.to_openai() for t in self._tools.values()] + [
-            e.to_openai() for e in self._ensembles.values()
-        ]
+        return [item.to_openai() for item in self.items()]
 
     def to_langchain(self) -> list:
-        return [t.to_langchain() for t in self._tools.values()] + [
-            e.to_langchain() for e in self._ensembles.values()
-        ]
+        return [item.to_langchain() for item in self.items()]

predikit-0.6.1/tests/test_cli.py

@@ -0,0 +1,219 @@
+import json
+
+import pytest
+
+joblib = pytest.importorskip("joblib")
+click_testing = pytest.importorskip("click.testing")
+
+from click.testing import CliRunner  # noqa: E402
+from sklearn.datasets import load_iris  # noqa: E402
+from sklearn.linear_model import LinearRegression, LogisticRegression  # noqa: E402
+
+from predikit.cli import cli  # noqa: E402
+
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+
+@pytest.fixture
+def reg_pkl(tmp_path):
+    """Regression model fitted with named features, so it has feature_names_in_."""
+    X, y = load_iris(return_X_y=True, as_frame=True)
+    model = LinearRegression().fit(X, y.astype(float))
+    path = tmp_path / "reg.pkl"
+    joblib.dump(model, path)
+    return str(path)
+
+
+@pytest.fixture
+def clf_pkl(tmp_path):
+    """Classifier fitted with named features."""
+    X, y = load_iris(return_X_y=True, as_frame=True)
+    model = LogisticRegression(max_iter=200).fit(X, y)
+    path = tmp_path / "clf.pkl"
+    joblib.dump(model, path)
+    return str(path)
+
+
+@pytest.fixture
+def unnamed_pkl(tmp_path):
+    """Model fitted without named features (numpy array)."""
+    X, y = load_iris(return_X_y=True)
+    model = LinearRegression().fit(X, y.astype(float))
+    path = tmp_path / "unnamed.pkl"
+    joblib.dump(model, path)
+    return str(path)
+
+
+def test_inspect_regression_shows_model_type(runner, reg_pkl):
+    result = runner.invoke(cli, ["inspect", reg_pkl])
+    assert result.exit_code == 0, result.output
+    assert "LinearRegression" in result.output
+    assert "regression" in result.output
+
+
+def test_inspect_classifier_shows_classes(runner, clf_pkl):
+    result = runner.invoke(cli, ["inspect", clf_pkl])
+    assert result.exit_code == 0, result.output
+    assert "classification" in result.output
+    assert "Classes" in result.output
+
+
+def test_inspect_shows_feature_names(runner, reg_pkl):
+    result = runner.invoke(cli, ["inspect", reg_pkl])
+    assert "sepal length (cm)" in result.output
+
+
+def test_inspect_emits_valid_openai_schema(runner, reg_pkl):
+    result = runner.invoke(cli, ["inspect", reg_pkl])
+    assert result.exit_code == 0
+    # Extract JSON from output (everything after "OpenAI schema:\n")
+    json_part = result.output.split("OpenAI schema:\n", 1)[1].strip()
+    schema = json.loads(json_part)
+    assert schema["type"] == "function"
+    assert "parameters" in schema["function"]
+
+
+def test_inspect_custom_name_and_description(runner, reg_pkl):
+    result = runner.invoke(
+        cli, ["inspect", reg_pkl, "--name", "my_tool", "--description", "my desc"]
+    )
+    assert result.exit_code == 0
+    json_part = result.output.split("OpenAI schema:\n", 1)[1].strip()
+    schema = json.loads(json_part)
+    assert schema["function"]["name"] == "my_tool"
+    assert schema["function"]["description"] == "my desc"
+
+
+def test_inspect_unnamed_model_skips_schema(runner, unnamed_pkl):
+    result = runner.invoke(cli, ["inspect", unnamed_pkl])
+    assert result.exit_code == 0
+    assert "unavailable" in result.output
+
+
+def test_inspect_missing_file(runner):
+    result = runner.invoke(cli, ["inspect", "does_not_exist.pkl"])
+    assert result.exit_code != 0
+
+
+def test_serve_requires_module_target(runner):
+    result = runner.invoke(cli, ["serve", "not-a-module-target"])
+    assert result.exit_code != 0
+    assert "MODULE:ATTRIBUTE" in result.output
+
+
+@pytest.fixture
+def registry_module(monkeypatch):
+    """A module exposing both a ToolRegistry instance and a factory returning one."""
+    import sys
+    import types
+
+    from pydantic import create_model
+
+    from predikit import ModelTool, ToolRegistry
+
+    class EchoModel:
+        def predict(self, X):
+            return [float(X[0][0])]
+
+    def build():
+        tool = ModelTool(
+            model=EchoModel(),
+            name="echo_value",
+            description="Echo a numeric value.",
+            input_schema=create_model("Input", value=(float, ...)),
+            output_name="value",
+            output_description="The value.",
+        )
+        return ToolRegistry([tool])
+
+    module = types.ModuleType("predikit_serve_fixture")
+    module.registry = build()
+    module.make_registry = build
+    monkeypatch.setitem(sys.modules, "predikit_serve_fixture", module)
+    return module
+
+
+@pytest.fixture
+def captured_run(monkeypatch):
+    """Stop short of actually serving; record how the server was configured."""
+    calls = {}
+
+    def fake_run(self, transport):
+        calls["transport"] = transport
+        calls["host"] = self.settings.host
+        calls["port"] = self.settings.port
+        calls["tools"] = sorted(self._tool_manager._tools)
+
+    pytest.importorskip("mcp")
+    from mcp.server.fastmcp import FastMCP
+
+    monkeypatch.setattr(FastMCP, "run", fake_run)
+    return calls
+
+
+def test_serve_loads_a_registry_instance(runner, registry_module, captured_run):
+    result = runner.invoke(cli, ["serve", "predikit_serve_fixture:registry"])
+    assert result.exit_code == 0, result.output
+    assert captured_run["transport"] == "stdio"
+    assert captured_run["tools"] == ["echo_value"]
+
+
+def test_serve_calls_a_registry_factory(runner, registry_module, captured_run):
+    result = runner.invoke(cli, ["serve", "predikit_serve_fixture:make_registry"])
+    assert result.exit_code == 0, result.output
+    assert captured_run["tools"] == ["echo_value"]
+
+
+def test_serve_passes_host_and_port(runner, registry_module, captured_run):
+    result = runner.invoke(
+        cli,
+        [
+            "serve",
+            "predikit_serve_fixture:registry",
+            "--transport",
+            "streamable-http",
+            "--host",
+            "0.0.0.0",
+            "--port",
+            "9123",
+        ],
+    )
+    assert result.exit_code == 0, result.output
+    assert (captured_run["transport"], captured_run["host"], captured_run["port"]) == (
+        "streamable-http",
+        "0.0.0.0",
+        9123,
+    )
+
+
+def test_serve_reports_an_unimportable_module(runner):
+    result = runner.invoke(cli, ["serve", "no_such_module_xyz:registry"])
+    assert result.exit_code != 0
+    assert "Could not import module 'no_such_module_xyz'" in result.output
+
+
+def test_serve_reports_a_missing_attribute(runner, registry_module):
+    result = runner.invoke(cli, ["serve", "predikit_serve_fixture:nope"])
+    assert result.exit_code != 0
+    assert "has no attribute 'nope'" in result.output
+
+
+def test_serve_does_not_disguise_errors_from_the_registry_factory(runner, monkeypatch):
+    """An ImportError raised *inside* the target must not read as a bad target."""
+    import sys
+    import types
+
+    def broken():
+        raise ImportError("optional backend missing")
+
+    module = types.ModuleType("predikit_broken_fixture")
+    module.make_registry = broken
+    monkeypatch.setitem(sys.modules, "predikit_broken_fixture", module)
+
+    result = runner.invoke(cli, ["serve", "predikit_broken_fixture:make_registry"])
+    assert result.exit_code != 0
+    assert isinstance(result.exception, ImportError)
+    assert "Could not import module" not in result.output

{predikit-0.5.2 → predikit-0.6.1}/tests/test_coerce.py

@@ -55,3 +55,14 @@ def test_coerce_inputs_missing_feature_raises():
     meta = {"feature_names": ["x", "y"]}
     with pytest.raises(ValueError, match="missing"):
         coerce_inputs(validated, meta)
+
+
+def test_bool_to_int_is_converted():
+    # isinstance(True, int) is True, so bools must be special-cased.
+    assert coerce_value(True, int) == 1
+    assert coerce_value(False, int) == 0
+    assert not isinstance(coerce_value(True, int), bool)
+
+
+def test_bool_to_bool_is_unchanged():
+    assert coerce_value(True, bool) is True