milton-mcp 0.1.0__tar.gz

milton_mcp-0.1.0/.github/workflows/ci.yaml

@@ -0,0 +1,23 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: ${{ matrix.python }}
+      - run: uv sync --group dev
+      - run: uv run ruff check .
+      - run: uv run ruff format --check .
+      - run: uv run pytest -q

milton_mcp-0.1.0/.github/workflows/release.yaml

@@ -0,0 +1,39 @@
+name: Release
+
+# Push a tag vX.Y.Z matching pyproject's version to publish to PyPI. Publishing uses PyPI
+# trusted publishing: the milton-mcp project on PyPI must list this repo, this workflow file
+# and the `pypi` environment as a trusted publisher.
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - name: Tag matches the package version
+        run: |
+          version=$(uv run --no-project python -c "import tomllib; print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])")
+          test "v${version}" = "${GITHUB_REF_NAME}" || { echo "tag ${GITHUB_REF_NAME} != v${version}"; exit 1; }
+      - run: uv sync --group dev
+      - run: uv run pytest -q
+      - run: uv build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

milton_mcp-0.1.0/.github/workflows/schema-drift.yaml

@@ -0,0 +1,15 @@
+name: Schema drift
+
+# Checks the bundled schemas.json against Milton's published OpenAPI spec and pricing.
+# A failure means Milton's API changed: run scripts/generate_schemas.py and release.
+on:
+  workflow_dispatch:
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - run: uv sync --group dev
+      - run: uv run python scripts/generate_schemas.py --check

milton_mcp-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+.venv/
+__pycache__/
+*.pyc
+.pytest_cache/
+.ruff_cache/
+dist/
+build/
+*.egg-info/
+.env

milton_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Milton Analytics LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

milton_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.5
+Name: milton-mcp
+Version: 0.1.0
+Summary: MCP server for Milton's analyst agents: technical, fundamental, macro, trade design and the full desk, through Milton's API.
+Project-URL: Homepage, https://withmilton.ai
+Project-URL: Documentation, https://withmilton.ai/docs/api/v1
+Project-URL: Source, https://github.com/Milton-Analytics-LLC/milton-mcp
+Author-email: Milton Analytics LLC <support@withmilton.ai>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,finance,mcp,milton,model-context-protocol,options,stocks
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.10
+Requires-Dist: mcp<3,>=2.3
+Description-Content-Type: text/markdown
+
+# milton-mcp
+
+An [MCP](https://modelcontextprotocol.io) server for [Milton](https://withmilton.ai)'s analyst agents. Add it
+to Claude Code, Claude Desktop, Cursor or your own agent, and the agent can ask Milton for a technical,
+fundamental or macro read, a risk-checked trade idea, or the full desk on a ticker.
+
+The server is a thin layer over Milton's [public API](https://withmilton.ai/docs/api/v1). The agents run
+on Milton's servers; this package only sends your requests and formats the results. You need a Milton
+account and an API token.
+
+## Install
+
+With [uv](https://docs.astral.sh/uv/) (no separate install step; `uvx` fetches and runs it):
+
+```sh
+uvx milton-mcp --version
+```
+
+Or with pip: `pip install milton-mcp`.
+
+## Get an API token
+
+Sign in at [withmilton.ai](https://withmilton.ai), open **Settings → API tokens** and create one. It starts
+with `mlt_`. Treat it like a password: it can start runs that bill to your balance.
+
+## Configure your client
+
+### Claude Code
+
+```sh
+claude mcp add milton -e MILTON_API_KEY=mlt_your_token -- uvx milton-mcp
+```
+
+### Claude Desktop, Cursor and other JSON-configured clients
+
+Claude Desktop: `claude_desktop_config.json`. Cursor: `~/.cursor/mcp.json` or `.cursor/mcp.json`.
+
+```json
+{
+  "mcpServers": {
+    "milton": {
+      "command": "uvx",
+      "args": ["milton-mcp"],
+      "env": { "MILTON_API_KEY": "mlt_your_token" }
+    }
+  }
+}
+```
+
+### Your own agent
+
+Any MCP client works. With the OpenAI Agents SDK, for example:
+
+```python
+from agents import Agent, Runner
+from agents.mcp import MCPServerStdio
+
+async with MCPServerStdio(
+    params={"command": "uvx", "args": ["milton-mcp"], "env": {"MILTON_API_KEY": "mlt_your_token"}},
+    client_session_timeout_seconds=70,
+) as milton:
+    agent = Agent(name="Analyst", instructions="...", mcp_servers=[milton])
+    result = await Runner.run(agent, "Give me a swing-trade technical read on NVDA using gpt-6.1-sol.")
+```
+
+A tool call can wait up to 50 seconds for a run to finish, so give your client a request timeout of at
+least 70 seconds.
+
+## Settings
+
+| Variable | Meaning |
+|---|---|
+| `MILTON_API_KEY` | Your API token (`mlt_…`). Required in stdio mode. |
+| `MILTON_DEFAULT_MODEL` | Optional. The model runs use when a call doesn't name one; `model` then becomes optional in the tool schemas. |
+| `MILTON_DEFAULT_EFFORT` | Optional. The reasoning effort runs use when a call doesn't name one. |
+| `MILTON_BASE_URL` | Optional. Defaults to `https://withmilton.ai`. |
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `milton_technical_analysis` | Multi-timeframe technical read of one US stock or ETF: directional bias and conviction, support and resistance, volatility posture. Inputs: `ticker`, `horizon`. |
+| `milton_fundamental_analysis` | Fundamental read from filings, financials and news: bias, valuation, business quality, drivers, risks. Input: `ticker`. |
+| `milton_macro_analysis` | Market-wide macro read: risk-on or risk-off regime, bias, timing, scheduled event risks, breadth. No ticker. |
+| `milton_quant_analysis` | One risk-checked trade (options or shares) for a ticker and horizon, sized against a hypothetical $100,000 portfolio. It can conclude no trade is worth taking. |
+| `milton_desk` | The full desk: macro, fundamental and technical reads, then a trade designed on them and reviewed by Milton's risk analyst. Takes several minutes. |
+| `milton_get_run` | Gets a run by `run_id`: its status and, once it completes, its result. Uses no tokens. |
+
+Every agent tool also takes `model` (any model Milton offers) and an optional `effort` (defaults to
+`high`, or the model's highest level). `horizon` is `intraday`, `swing`, `position` or `long_term`.
+
+### What comes back
+
+A short digest the model can read (stance, conviction, summary, key levels, risks, how fresh the data
+is, cost), the full result as structured content, and links to the run in Milton and in the API.
+
+A run that hasn't finished after 50 seconds comes back as a `run_id` instead; `milton_get_run` waits up to
+50 seconds per call for it. A desk run always returns its `run_id` at once.
+
+### Repeated calls
+
+MCP clients sometimes re-send a call when a connection drops. An identical call (same tool and inputs)
+within 10 minutes returns the same run and isn't billed again. A call with any different input starts a
+new run.
+
+## Cost
+
+Runs bill the tokens they use at the chosen model's rates ([pricing](https://withmilton.ai/api/v1/pricing))
+against your Milton balance; a desk run bills every analyst it runs. Failed runs aren't billed. Pick a
+smaller model or a lower effort for cheaper, faster runs.
+
+## Running it on your own server
+
+`--http` serves MCP over Streamable HTTP (stateless, JSON responses), so agents on other machines can
+reach it:
+
+```sh
+milton-mcp --http --host 0.0.0.0 --port 8000      # endpoint: http://<host>:8000/mcp
+```
+
+In HTTP mode the server holds no API token. Every request must carry the caller's token as
+`Authorization: Bearer mlt_…`, which is passed on to Milton; a request without one gets a 401. Put it
+behind TLS if it's reachable beyond your own network.
+
+## Development
+
+```sh
+uv sync --group dev
+uv run pytest
+uv run ruff check . && uv run ruff format --check .
+```
+
+The tools' input schemas, the result schema and the fallback model list are generated from Milton's
+published API description:
+
+```sh
+uv run python scripts/generate_schemas.py            # from https://withmilton.ai
+uv run python scripts/generate_schemas.py --check    # fails if src/milton_mcp/schemas.json is stale
+```
+
+Releases publish to PyPI when a `vX.Y.Z` tag matching `pyproject.toml`'s version is pushed.
+
+## Disclosures
+
+Milton is not a registered investment adviser, broker-dealer or financial planner. Its outputs are
+AI-generated general information, not personalized investment advice or a recommendation to buy or sell
+any security. Each result carries Milton's full disclosures.
+
+## License
+
+MIT

milton_mcp-0.1.0/README.md

@@ -0,0 +1,151 @@
+# milton-mcp
+
+An [MCP](https://modelcontextprotocol.io) server for [Milton](https://withmilton.ai)'s analyst agents. Add it
+to Claude Code, Claude Desktop, Cursor or your own agent, and the agent can ask Milton for a technical,
+fundamental or macro read, a risk-checked trade idea, or the full desk on a ticker.
+
+The server is a thin layer over Milton's [public API](https://withmilton.ai/docs/api/v1). The agents run
+on Milton's servers; this package only sends your requests and formats the results. You need a Milton
+account and an API token.
+
+## Install
+
+With [uv](https://docs.astral.sh/uv/) (no separate install step; `uvx` fetches and runs it):
+
+```sh
+uvx milton-mcp --version
+```
+
+Or with pip: `pip install milton-mcp`.
+
+## Get an API token
+
+Sign in at [withmilton.ai](https://withmilton.ai), open **Settings → API tokens** and create one. It starts
+with `mlt_`. Treat it like a password: it can start runs that bill to your balance.
+
+## Configure your client
+
+### Claude Code
+
+```sh
+claude mcp add milton -e MILTON_API_KEY=mlt_your_token -- uvx milton-mcp
+```
+
+### Claude Desktop, Cursor and other JSON-configured clients
+
+Claude Desktop: `claude_desktop_config.json`. Cursor: `~/.cursor/mcp.json` or `.cursor/mcp.json`.
+
+```json
+{
+  "mcpServers": {
+    "milton": {
+      "command": "uvx",
+      "args": ["milton-mcp"],
+      "env": { "MILTON_API_KEY": "mlt_your_token" }
+    }
+  }
+}
+```
+
+### Your own agent
+
+Any MCP client works. With the OpenAI Agents SDK, for example:
+
+```python
+from agents import Agent, Runner
+from agents.mcp import MCPServerStdio
+
+async with MCPServerStdio(
+    params={"command": "uvx", "args": ["milton-mcp"], "env": {"MILTON_API_KEY": "mlt_your_token"}},
+    client_session_timeout_seconds=70,
+) as milton:
+    agent = Agent(name="Analyst", instructions="...", mcp_servers=[milton])
+    result = await Runner.run(agent, "Give me a swing-trade technical read on NVDA using gpt-6.1-sol.")
+```
+
+A tool call can wait up to 50 seconds for a run to finish, so give your client a request timeout of at
+least 70 seconds.
+
+## Settings
+
+| Variable | Meaning |
+|---|---|
+| `MILTON_API_KEY` | Your API token (`mlt_…`). Required in stdio mode. |
+| `MILTON_DEFAULT_MODEL` | Optional. The model runs use when a call doesn't name one; `model` then becomes optional in the tool schemas. |
+| `MILTON_DEFAULT_EFFORT` | Optional. The reasoning effort runs use when a call doesn't name one. |
+| `MILTON_BASE_URL` | Optional. Defaults to `https://withmilton.ai`. |
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `milton_technical_analysis` | Multi-timeframe technical read of one US stock or ETF: directional bias and conviction, support and resistance, volatility posture. Inputs: `ticker`, `horizon`. |
+| `milton_fundamental_analysis` | Fundamental read from filings, financials and news: bias, valuation, business quality, drivers, risks. Input: `ticker`. |
+| `milton_macro_analysis` | Market-wide macro read: risk-on or risk-off regime, bias, timing, scheduled event risks, breadth. No ticker. |
+| `milton_quant_analysis` | One risk-checked trade (options or shares) for a ticker and horizon, sized against a hypothetical $100,000 portfolio. It can conclude no trade is worth taking. |
+| `milton_desk` | The full desk: macro, fundamental and technical reads, then a trade designed on them and reviewed by Milton's risk analyst. Takes several minutes. |
+| `milton_get_run` | Gets a run by `run_id`: its status and, once it completes, its result. Uses no tokens. |
+
+Every agent tool also takes `model` (any model Milton offers) and an optional `effort` (defaults to
+`high`, or the model's highest level). `horizon` is `intraday`, `swing`, `position` or `long_term`.
+
+### What comes back
+
+A short digest the model can read (stance, conviction, summary, key levels, risks, how fresh the data
+is, cost), the full result as structured content, and links to the run in Milton and in the API.
+
+A run that hasn't finished after 50 seconds comes back as a `run_id` instead; `milton_get_run` waits up to
+50 seconds per call for it. A desk run always returns its `run_id` at once.
+
+### Repeated calls
+
+MCP clients sometimes re-send a call when a connection drops. An identical call (same tool and inputs)
+within 10 minutes returns the same run and isn't billed again. A call with any different input starts a
+new run.
+
+## Cost
+
+Runs bill the tokens they use at the chosen model's rates ([pricing](https://withmilton.ai/api/v1/pricing))
+against your Milton balance; a desk run bills every analyst it runs. Failed runs aren't billed. Pick a
+smaller model or a lower effort for cheaper, faster runs.
+
+## Running it on your own server
+
+`--http` serves MCP over Streamable HTTP (stateless, JSON responses), so agents on other machines can
+reach it:
+
+```sh
+milton-mcp --http --host 0.0.0.0 --port 8000      # endpoint: http://<host>:8000/mcp
+```
+
+In HTTP mode the server holds no API token. Every request must carry the caller's token as
+`Authorization: Bearer mlt_…`, which is passed on to Milton; a request without one gets a 401. Put it
+behind TLS if it's reachable beyond your own network.
+
+## Development
+
+```sh
+uv sync --group dev
+uv run pytest
+uv run ruff check . && uv run ruff format --check .
+```
+
+The tools' input schemas, the result schema and the fallback model list are generated from Milton's
+published API description:
+
+```sh
+uv run python scripts/generate_schemas.py            # from https://withmilton.ai
+uv run python scripts/generate_schemas.py --check    # fails if src/milton_mcp/schemas.json is stale
+```
+
+Releases publish to PyPI when a `vX.Y.Z` tag matching `pyproject.toml`'s version is pushed.
+
+## Disclosures
+
+Milton is not a registered investment adviser, broker-dealer or financial planner. Its outputs are
+AI-generated general information, not personalized investment advice or a recommendation to buy or sell
+any security. Each result carries Milton's full disclosures.
+
+## License
+
+MIT

milton_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "milton-mcp"
+version = "0.1.0"
+description = "MCP server for Milton's analyst agents: technical, fundamental, macro, trade design and the full desk, through Milton's API."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "Milton Analytics LLC", email = "support@withmilton.ai" }]
+keywords = ["mcp", "model-context-protocol", "milton", "finance", "agents", "stocks", "options"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Intended Audience :: Financial and Insurance Industry",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Topic :: Office/Business :: Financial :: Investment",
+]
+dependencies = ["mcp>=2.3,<3"]
+
+[project.urls]
+Homepage = "https://withmilton.ai"
+Documentation = "https://withmilton.ai/docs/api/v1"
+Source = "https://github.com/Milton-Analytics-LLC/milton-mcp"
+
+[project.scripts]
+milton-mcp = "milton_mcp.__main__:main"
+
+[dependency-groups]
+dev = ["pytest>=8", "ruff==0.15.15", "pyyaml>=6"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/milton_mcp"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src", "."]
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "B", "UP", "SIM", "RUF"]

milton_mcp-0.1.0/scripts/generate_schemas.py

@@ -0,0 +1,130 @@
+"""Generate src/milton_mcp/schemas.json from Milton's published OpenAPI spec and pricing.
+
+The tools' input schemas, the run envelope (each tool's outputSchema) and the fallback model list
+all come from Milton's public API description, so the server never drifts from the API it calls:
+
+    python scripts/generate_schemas.py                       # from https://withmilton.ai
+    python scripts/generate_schemas.py --spec ../milton/go-services/cmd/api/openapi.yaml \\
+        --pricing pricing.json                               # from a local checkout
+    python scripts/generate_schemas.py --check               # exit 1 if the bundled copy is stale
+"""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import json
+import sys
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+DEFAULT_BASE = "https://withmilton.ai"
+OUT_PATH = Path(__file__).resolve().parents[1] / "src" / "milton_mcp" / "schemas.json"
+
+# The agents this server exposes. risk and portfolio are left out for now; desk runs without
+# portfolio_id (it sizes on a hypothetical portfolio).
+AGENTS = ("technical", "fundamental", "macro", "quant", "desk")
+DROPPED_FIELDS = {"portfolio_id"}
+# Added by the server itself, with the offered models and effort levels as enums.
+MODEL_FIELDS = {"model", "effort"}
+# Top-level combinators some MCP hosts reject in a tool's input schema.
+TOP_LEVEL_COMBINATORS = {"oneOf", "anyOf", "allOf", "dependentRequired"}
+# OpenAPI-only formats; strict JSON Schema validators reject an unknown format.
+OPENAPI_FORMATS = {"int32", "int64", "float", "double", "byte", "binary", "password"}
+
+
+def _load(source: str) -> str:
+    if source.startswith(("http://", "https://")):
+        # withmilton.ai's Cloudflare rules answer urllib's default "Python-urllib/x.y" with a 403.
+        request = urllib.request.Request(source, headers={"User-Agent": "milton-mcp-schema-generator"})
+        with urllib.request.urlopen(request, timeout=30) as resp:
+            return resp.read().decode()
+    return Path(source).read_text()
+
+
+def _camel(name: str) -> str:
+    return "".join(part.capitalize() for part in name.split("_"))
+
+
+def _input_schema(spec: dict[str, Any], agent: str) -> dict[str, Any]:
+    schema = copy.deepcopy(spec["components"]["schemas"][f"{_camel(agent)}RunRequest"])
+    for key in TOP_LEVEL_COMBINATORS | {"description"}:
+        schema.pop(key, None)
+    props = schema.get("properties", {})
+    for name in DROPPED_FIELDS | MODEL_FIELDS:
+        props.pop(name, None)
+    schema["properties"] = props
+    schema["required"] = [r for r in schema.get("required", []) if r in props]
+    schema["additionalProperties"] = False
+    return schema
+
+
+def _waits(spec: dict[str, Any], agent: str) -> bool:
+    """Whether the start route takes ?wait (desk, the long-running agent, doesn't)."""
+    params = spec["paths"][f"/api/v1/agents/{agent}/runs"]["post"].get("parameters", [])
+    return any(p.get("$ref", "").endswith("/AgentRunWait") for p in params)
+
+
+def _to_json_schema(node: Any, schemas: dict[str, Any]) -> Any:
+    """OpenAPI 3.0 → JSON Schema 2020-12: inline component $refs, nullable → anyOf with null."""
+    if isinstance(node, list):
+        return [_to_json_schema(x, schemas) for x in node]
+    if not isinstance(node, dict):
+        return node
+    ref = node.get("$ref")
+    if isinstance(ref, str) and ref.startswith("#/components/schemas/"):
+        return _to_json_schema(schemas[ref.removeprefix("#/components/schemas/")], schemas)
+    out = {k: _to_json_schema(v, schemas) for k, v in node.items() if k != "nullable"}
+    if out.get("format") in OPENAPI_FORMATS:
+        del out["format"]
+    if node.get("nullable") is True:
+        # anyOf with single-type branches, not a type array: hosts that map tool schemas onto a
+        # single-`type` dialect reject type arrays.
+        description = out.pop("description", None)
+        out = {"anyOf": [out, {"type": "null"}]}
+        if description:
+            out["description"] = description
+    return out
+
+
+def build(spec_text: str, pricing: dict[str, Any]) -> dict[str, Any]:
+    spec = yaml.safe_load(spec_text)
+    schemas = spec["components"]["schemas"]
+    agents = {agent: {"input_schema": _input_schema(spec, agent), "waits": _waits(spec, agent)} for agent in AGENTS}
+    envelope = _to_json_schema(schemas["AgentRunEnvelope"], schemas)
+    efforts = pricing.get("efforts")
+    if not efforts:
+        raise SystemExit("pricing has no efforts: the API predates per-run model and effort")
+    return {
+        "agents": agents,
+        "envelope_schema": envelope,
+        "models": {model: list(levels) for model, levels in sorted(efforts.items())},
+    }
+
+
+def render(data: dict[str, Any]) -> str:
+    return json.dumps(data, indent=2, sort_keys=True) + "\n"
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--spec", default=f"{DEFAULT_BASE}/api/v1/openapi.yaml", help="OpenAPI spec URL or path")
+    parser.add_argument("--pricing", default=f"{DEFAULT_BASE}/api/v1/pricing", help="pricing JSON URL or path")
+    parser.add_argument("--check", action="store_true", help="fail if the bundled schemas.json is stale")
+    args = parser.parse_args(argv)
+
+    text = render(build(_load(args.spec), json.loads(_load(args.pricing))))
+    if args.check:
+        if OUT_PATH.read_text() != text:
+            print(f"{OUT_PATH} is stale; run scripts/generate_schemas.py", file=sys.stderr)
+            return 1
+        return 0
+    OUT_PATH.write_text(text)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

milton_mcp-0.1.0/src/milton_mcp/__init__.py

@@ -0,0 +1,9 @@
+"""MCP server for Milton's analyst agents."""
+
+import importlib.metadata
+
+# pyproject.toml is the one place the version is set; the release workflow checks the tag against it.
+try:
+    __version__ = importlib.metadata.version("milton-mcp")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "0+unknown"