reactor-mcp-server 1.0.1__tar.gz

reactor_mcp_server-1.0.1/.gitignore

@@ -0,0 +1 @@
+*.egg-info/

reactor_mcp_server-1.0.1/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.5
+Name: reactor_mcp_server
+Version: 1.0.1
+Summary: An extensible MCP server built on Reactor: tools are contributions, and a contribution can be extended
+Project-URL: Homepage, https://datalayer.ai
+Project-URL: Source, https://github.com/datalayer/reactor
+Author-email: Datalayer <support@datalayer.io>
+License: Datalayer License
+Keywords: mcp,plugins,reactor,tools
+Classifier: Intended Audience :: Developers
+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
+Requires-Python: >=3.10
+Requires-Dist: datalayer-reactor>=1.0.2
+Requires-Dist: mcp<3,>=2
+Requires-Dist: starlette
+Provides-Extra: server
+Requires-Dist: uvicorn[standard]; extra == 'server'
+Provides-Extra: test
+Requires-Dist: httpx; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-asyncio; extra == 'test'
+Requires-Dist: uvicorn[standard]; extra == 'test'
+Description-Content-Type: text/markdown
+
+<!--
+  Copyright (c) 2026-Present Datalayer, Inc.
+
+  Datalayer License
+-->
+
+[![Datalayer](https://assets.datalayer.tech/datalayer-25.svg)](https://datalayer.ai)
+
+# Reactor MCP Server
+
+An extensible [MCP](https://modelcontextprotocol.io) server built on
+[Reactor](https://github.com/datalayer/reactor). Three ideas, and the rest
+follows from them.
+
+## A tool is a contribution
+
+An extension does not reach into a server and register a function on it. It
+*offers* a tool at a contribution point, and the host builds a server from what
+has been offered:
+
+```python
+from reactor import PluginManifest
+from reactor_mcp_server import McpExtension, tool
+
+class Sandboxes(McpExtension):
+    def manifest(self) -> PluginManifest:
+        return PluginManifest(name="sandboxes", version="1.0.0")
+
+    @tool(title="Launch Sandbox")
+    async def launch_sandbox(self, sandbox_name: str, variant: str = "eval") -> dict:
+        """Launch a sandbox for this session to run code in."""
+        return await launch(sandbox_name, variant)
+```
+
+Offering rather than registering is what makes the next part possible — and it
+means what a server is made of can be read, listed and drawn before one is
+built.
+
+## A contribution can be extended
+
+An extension may narrow, wrap or re-describe a tool **another** extension
+offered:
+
+```python
+class DatalayerSandboxes(McpExtension):
+    def manifest(self) -> PluginManifest:
+        return PluginManifest(name="sandboxes-datalayer", version="1.0.0")
+
+    def tool_extensions(self):
+        def on_datalayer(handler):
+            async def narrowed(sandbox_name: str, environment: str = "ai-env") -> dict:
+                return await handler(sandbox_name, variant="datalayer")
+            return narrowed
+
+        return (("launch_sandbox", ToolExtension(
+            wrap=on_datalayer,
+            description="Launch a sandbox on Datalayer.",
+        )),)
+```
+
+Without this, an extension that wants to narrow somebody else's tool has one
+lever: register a tool of the same name and hope to load second, because the
+SDK keeps the first registration. That makes the outcome depend on the order
+two distributions happened to be installed in — it works where the entry point
+names sort the right way and silently does nothing where they do not.
+Extensions are applied by name, in a declared order, on every machine.
+
+## The URL decides what is served
+
+Tools belong to named toolsets, and a client says which ones it wants in the
+URL it connects to:
+
+| URL | What the client gets |
+| --- | --- |
+| `https://mcp.example.com/mcp` | every toolset that is on by default |
+| `https://mcp.example.com/mcp?benchmarks` | the defaults, and `benchmarks` |
+| `https://mcp.example.com/mcp?toolsets=spaces,library` | the defaults, and those two |
+| `https://mcp.example.com/mcp?only=spaces` | `spaces` alone, plus the always-on toolsets |
+| `https://mcp.example.com/mcp?without=sandboxes` | the defaults, less that one |
+
+A toolset that is `default=False` costs a client that did not ask for it
+nothing: the extension offering it declares
+`activation_events=[on_toolset("benchmarks")]` and is not registered at all
+until a URL names it.
+
+`GET /toolsets` answers what a deployment offers and what a given URL would
+activate, so a client can be told which name to put in its URL.
+
+## Running it
+
+```bash
+pip install reactor_mcp_server
+reactor-mcp-server --port 4040
+```
+
+Every extension installed on the `reactor.mcp.extensions` entry-point group is
+discovered, started as a reactor plugin, and served. A deployment adds a
+toolset by installing a distribution:
+
+```toml
+[project.entry-points."reactor.mcp.extensions"]
+sandboxes = "my_package:SandboxesExtension"
+```
+
+`REACTOR_MCP_EXTENSIONS=a,b` narrows discovery to the names it lists, which is
+what makes a tool list reproducible on a machine that happens to carry an extra
+extension.
+
+## In a server of your own
+
+```python
+from reactor_mcp_server import build_host, create_mcp_app, load_extensions
+
+host = build_host(load_extensions())
+app = create_mcp_app(host, path="/mcp")
+```
+
+`McpHost` owns the reactor platform, so activation events, enablement,
+per-tenant scoping and disposal work as they do for any other reactor plugin,
+and a server is built once per distinct set of toolsets and shared.
+
+## License
+
+Datalayer License.

reactor_mcp_server-1.0.1/README.md

@@ -0,0 +1,124 @@
+<!--
+  Copyright (c) 2026-Present Datalayer, Inc.
+
+  Datalayer License
+-->
+
+[![Datalayer](https://assets.datalayer.tech/datalayer-25.svg)](https://datalayer.ai)
+
+# Reactor MCP Server
+
+An extensible [MCP](https://modelcontextprotocol.io) server built on
+[Reactor](https://github.com/datalayer/reactor). Three ideas, and the rest
+follows from them.
+
+## A tool is a contribution
+
+An extension does not reach into a server and register a function on it. It
+*offers* a tool at a contribution point, and the host builds a server from what
+has been offered:
+
+```python
+from reactor import PluginManifest
+from reactor_mcp_server import McpExtension, tool
+
+class Sandboxes(McpExtension):
+    def manifest(self) -> PluginManifest:
+        return PluginManifest(name="sandboxes", version="1.0.0")
+
+    @tool(title="Launch Sandbox")
+    async def launch_sandbox(self, sandbox_name: str, variant: str = "eval") -> dict:
+        """Launch a sandbox for this session to run code in."""
+        return await launch(sandbox_name, variant)
+```
+
+Offering rather than registering is what makes the next part possible — and it
+means what a server is made of can be read, listed and drawn before one is
+built.
+
+## A contribution can be extended
+
+An extension may narrow, wrap or re-describe a tool **another** extension
+offered:
+
+```python
+class DatalayerSandboxes(McpExtension):
+    def manifest(self) -> PluginManifest:
+        return PluginManifest(name="sandboxes-datalayer", version="1.0.0")
+
+    def tool_extensions(self):
+        def on_datalayer(handler):
+            async def narrowed(sandbox_name: str, environment: str = "ai-env") -> dict:
+                return await handler(sandbox_name, variant="datalayer")
+            return narrowed
+
+        return (("launch_sandbox", ToolExtension(
+            wrap=on_datalayer,
+            description="Launch a sandbox on Datalayer.",
+        )),)
+```
+
+Without this, an extension that wants to narrow somebody else's tool has one
+lever: register a tool of the same name and hope to load second, because the
+SDK keeps the first registration. That makes the outcome depend on the order
+two distributions happened to be installed in — it works where the entry point
+names sort the right way and silently does nothing where they do not.
+Extensions are applied by name, in a declared order, on every machine.
+
+## The URL decides what is served
+
+Tools belong to named toolsets, and a client says which ones it wants in the
+URL it connects to:
+
+| URL | What the client gets |
+| --- | --- |
+| `https://mcp.example.com/mcp` | every toolset that is on by default |
+| `https://mcp.example.com/mcp?benchmarks` | the defaults, and `benchmarks` |
+| `https://mcp.example.com/mcp?toolsets=spaces,library` | the defaults, and those two |
+| `https://mcp.example.com/mcp?only=spaces` | `spaces` alone, plus the always-on toolsets |
+| `https://mcp.example.com/mcp?without=sandboxes` | the defaults, less that one |
+
+A toolset that is `default=False` costs a client that did not ask for it
+nothing: the extension offering it declares
+`activation_events=[on_toolset("benchmarks")]` and is not registered at all
+until a URL names it.
+
+`GET /toolsets` answers what a deployment offers and what a given URL would
+activate, so a client can be told which name to put in its URL.
+
+## Running it
+
+```bash
+pip install reactor_mcp_server
+reactor-mcp-server --port 4040
+```
+
+Every extension installed on the `reactor.mcp.extensions` entry-point group is
+discovered, started as a reactor plugin, and served. A deployment adds a
+toolset by installing a distribution:
+
+```toml
+[project.entry-points."reactor.mcp.extensions"]
+sandboxes = "my_package:SandboxesExtension"
+```
+
+`REACTOR_MCP_EXTENSIONS=a,b` narrows discovery to the names it lists, which is
+what makes a tool list reproducible on a machine that happens to carry an extra
+extension.
+
+## In a server of your own
+
+```python
+from reactor_mcp_server import build_host, create_mcp_app, load_extensions
+
+host = build_host(load_extensions())
+app = create_mcp_app(host, path="/mcp")
+```
+
+`McpHost` owns the reactor platform, so activation events, enablement,
+per-tenant scoping and disposal work as they do for any other reactor plugin,
+and a server is built once per distinct set of toolsets and shared.
+
+## License
+
+Datalayer License.

reactor_mcp_server-1.0.1/pyproject.toml

@@ -0,0 +1,51 @@
+# Copyright (c) 2026-Present Datalayer, Inc.
+#
+# Datalayer License
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "reactor_mcp_server"
+version = "1.0.1"
+description = "An extensible MCP server built on Reactor: tools are contributions, and a contribution can be extended"
+readme = "README.md"
+license = { text = "Datalayer License" }
+requires-python = ">=3.10"
+authors = [{ name = "Datalayer", email = "support@datalayer.io" }]
+keywords = ["mcp", "reactor", "plugins", "tools"]
+classifiers = [
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "datalayer_reactor>=1.0.2",
+    "mcp>=2,<3",
+    "starlette",
+]
+
+[project.optional-dependencies]
+server = ["uvicorn[standard]"]
+test = ["pytest", "pytest-asyncio", "httpx", "uvicorn[standard]"]
+
+[project.scripts]
+reactor-mcp-server = "reactor_mcp_server.__main__:main"
+
+# An MCP extension is discovered here. One group, so a distribution that
+# carries several extensions lists them all and a host loads them by name.
+[project.entry-points."reactor.mcp.extensions"]
+
+[project.urls]
+Homepage = "https://datalayer.ai"
+Source = "https://github.com/datalayer/reactor"
+
+[tool.hatch.build.targets.wheel]
+packages = ["reactor_mcp_server"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

reactor_mcp_server-1.0.1/reactor_mcp_server/__init__.py

@@ -0,0 +1,93 @@
+# Copyright (c) 2026-Present Datalayer, Inc.
+#
+# Datalayer License
+
+"""An extensible MCP server built on Reactor.
+
+Three ideas, and the rest follows:
+
+* **A tool is a contribution.** An extension offers tools at a contribution
+  point instead of registering them on a server object, so what a server is
+  made of can be read before one is built.
+* **A contribution can be extended.** An extension may narrow, wrap or
+  re-describe a tool another extension offered, by name and in a declared
+  order — rather than registering a tool of the same name and hoping to load
+  second.
+* **The URL decides what is served.** Tools belong to named toolsets, and a
+  client says which ones it wants in the URL it connects to:
+  ``https://mcp.example.com/mcp?benchmarks``.
+
+@module reactor_mcp_server
+"""
+
+from reactor_mcp_server.app import ToolsetRouter, create_mcp_app
+from reactor_mcp_server.extension import (
+    McpExtension,
+    load_extensions,
+    manifest_of,
+)
+from reactor_mcp_server.points import (
+    ENTRY_POINT_GROUP,
+    PROMPTS,
+    RESOURCES,
+    TOOLS,
+    TOOLSETS,
+    on_toolset,
+)
+from reactor_mcp_server.server import (
+    BuiltServer,
+    McpHost,
+    build_host,
+    put_on_server,
+)
+from reactor_mcp_server.tools import (
+    Handler,
+    ToolExtension,
+    ToolSpec,
+    Wrapper,
+    resolve,
+    tool,
+    tool_spec_of,
+)
+from reactor_mcp_server.toolsets import (
+    Selection,
+    Toolset,
+    activation_key,
+    active_toolsets,
+    parse_selection,
+    unknown_names,
+)
+
+__version__ = "1.0.1"
+
+__all__ = [
+    "BuiltServer",
+    "ENTRY_POINT_GROUP",
+    "Handler",
+    "McpExtension",
+    "McpHost",
+    "PROMPTS",
+    "RESOURCES",
+    "Selection",
+    "TOOLS",
+    "TOOLSETS",
+    "ToolExtension",
+    "ToolSpec",
+    "Toolset",
+    "ToolsetRouter",
+    "Wrapper",
+    "__version__",
+    "activation_key",
+    "active_toolsets",
+    "build_host",
+    "create_mcp_app",
+    "load_extensions",
+    "manifest_of",
+    "on_toolset",
+    "parse_selection",
+    "put_on_server",
+    "resolve",
+    "tool",
+    "tool_spec_of",
+    "unknown_names",
+]

reactor_mcp_server-1.0.1/reactor_mcp_server/__main__.py

@@ -0,0 +1,71 @@
+# Copyright (c) 2026-Present Datalayer, Inc.
+#
+# Datalayer License
+
+"""Run the installed MCP extensions as a reactor application.
+
+``python -m reactor_mcp_server`` — or ``reactor-mcp-server`` — discovers every
+extension on the ``reactor.mcp.extensions`` entry-point group, starts a reactor
+platform with them, and serves them over streamable HTTP. A deployment adds a
+toolset by installing a distribution; nothing here is edited.
+
+@module reactor_mcp_server.__main__
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+
+from reactor_mcp_server.app import create_mcp_app
+from reactor_mcp_server.extension import load_extensions
+from reactor_mcp_server.server import build_host
+
+#: Entry-point names to load, to the exclusion of everything else installed.
+#: What makes a tool list reproducible on a machine that happens to carry an
+#: extra extension.
+EXTENSIONS_ENV = "REACTOR_MCP_EXTENSIONS"
+
+
+def parser() -> argparse.ArgumentParser:
+    parsed = argparse.ArgumentParser(
+        prog="reactor-mcp-server",
+        description="Serve the installed MCP extensions over streamable HTTP.",
+    )
+    parsed.add_argument("--host", default=os.environ.get("REACTOR_MCP_HOST", "0.0.0.0"))
+    parsed.add_argument(
+        "--port", type=int, default=int(os.environ.get("REACTOR_MCP_PORT", "4040"))
+    )
+    parsed.add_argument("--path", default=os.environ.get("REACTOR_MCP_PATH", "/mcp"))
+    parsed.add_argument(
+        "--name", default=os.environ.get("REACTOR_MCP_NAME", "reactor-mcp-server")
+    )
+    parsed.add_argument(
+        "--extension",
+        action="append",
+        default=None,
+        help="Load only this extension; repeatable.",
+    )
+    parsed.add_argument("--log-level", default=os.environ.get("REACTOR_MCP_LOG", "info"))
+    return parsed
+
+
+def main(argv: list[str] | None = None) -> None:
+    arguments = parser().parse_args(argv)
+    logging.basicConfig(level=arguments.log_level.upper())
+    names = arguments.extension or [
+        part.strip()
+        for part in (os.environ.get(EXTENSIONS_ENV) or "").split(",")
+        if part.strip()
+    ]
+    host = build_host(load_extensions(names or None), name=arguments.name)
+    app = create_mcp_app(host, path=arguments.path)
+
+    import uvicorn  # noqa: PLC0415 - only the serving path needs it
+
+    uvicorn.run(app, host=arguments.host, port=arguments.port, log_level=arguments.log_level)
+
+
+if __name__ == "__main__":
+    main()