modelchoice-mcp 0.0.1__tar.gz

modelchoice_mcp-0.0.1/.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+permissions: {}
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+      - name: Sync (with dev extras)
+        run: uv sync --extra dev
+      - name: Ruff
+        run: uv run ruff check src tests
+      - name: Mypy
+        run: uv run mypy src
+      - name: Pytest
+        run: uv run pytest -q

modelchoice_mcp-0.0.1/.github/workflows/release.yml

@@ -0,0 +1,59 @@
+# Release pipeline. On a version tag (v*), build the wheel + sdist,
+# publish to PyPI via trusted publishing, and cut a GitHub release.
+#
+# One-time setup before the first tag:
+#   1. Create the PyPI project's trusted publisher
+#      (https://pypi.org/manage/account/publishing/) pointing at this
+#      repo + this workflow under the environment name "pypi". No tokens.
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions: {}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - name: Build sdist + wheel
+        run: uv build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish-pypi:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write # PyPI trusted publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+  github-release:
+    needs: publish-pypi
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - name: Create GitHub release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: dist/*
+          generate_release_notes: true

modelchoice_mcp-0.0.1/.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.py[cod]
+.venv/
+.uv/
+uv.lock
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+~$*.xlsx
+*.tmp

modelchoice_mcp-0.0.1/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: modelchoice-mcp
+Version: 0.0.1
+Summary: An open Model Context Protocol server for Vose Software's ModelChoice decision-tree add-in for Excel.
+Author: Vose Software
+License: MIT
+Requires-Python: >=3.11
+Requires-Dist: mcp>=1.2.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: xlwings>=0.30
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# ModelChoice MCP
+
+**An open Model Context Protocol server for [Vose Software's ModelChoice](https://www.vosesoftware.com) — the decision-tree add-in for Excel.**
+
+A sibling to [`modelrisk-mcp`](https://github.com/vosesoftware/modelrisk-mcp): where that server brings Monte Carlo risk modelling into a conversation, this one brings **decision analysis** — building, reading, rolling back, and analysing decision trees in Excel.
+
+> **Status: `0.0.1` — Phase 1 MCP server (read-only).** Three tools (`list_trees`, `get_tree`, `roll_up`) over a proven read path. Building/analysis tools are on the roadmap below.
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `list_trees` | List the decision trees in a workbook with node-type counts. |
+| `get_tree` | Full structure of one tree — decision / chance / terminal nodes, branches, probabilities, values. |
+| `roll_up` | Roll the tree back to its expected values and **optimal policy** — the decision recommendation, in plain English. |
+| `verify_rollback` | Cross-check our rollback against the `MC_V_<id>` cells ModelChoice itself wrote — a correctness guarantee when the tree has been rendered. |
+
+Run it: `uv run python -m modelchoice_mcp` (stdio), or wire `modelchoice-mcp` into Claude Desktop like any MCP server.
+
+## How it works
+
+ModelChoice is a C# .NET (Excel-DNA) add-in. Unlike ModelRisk it exposes **no COM object model and no compute worksheet functions** — but it persists the *entire* decision tree as JSON in a very-hidden worksheet (`_MC_Store`), and the rollback logic is fully captured in that model. So this server can:
+
+- **Read** every tree in a workbook by reassembling the `_MC_Store` payload (chunked across columns, v2-envelope or v1-legacy format) and parsing the model JSON.
+- **Roll back** each tree to its expected values and **optimal policy** in pure Python — reproducing ModelChoice's own rollback (terminal payoff = accumulated branch values; chance = auto-normalized probability-weighted EV; decision = max/min by `Maximize`). **No add-in needs to be loaded** — it reads the saved model directly.
+
+The Python roller is validated against ModelChoice's own authoritative C# test (`Model_Validate_Compile_Rollback_Works`): a decision/chance tree that rolls back to EV 50 with the optimal option selected — and matches exactly.
+
+## Roadmap
+
+- **Phase 0 (done):** the read + rollback engine — parse `_MC_Store`, reconstruct each tree, roll back to EV + optimal policy. Validated against ModelChoice's own C# rollback test.
+- **Phase 1 (done):** the MCP server — `list_trees`, `get_tree`, `roll_up`, proven live against a real workbook.
+- **Phase 1b (done):** `verify_rollback` cross-checks our EVs against the `MC_V_<id>` named ranges; CI (ruff + mypy + pytest) and a tag-driven PyPI release pipeline; wheel + sdist build. *(First publish awaits a PyPI trusted-publisher; the live `MC_V_` cross-check awaits a real rendered tree.)*
+- **Phase 2:** drive analyses. ModelChoice's analyses (sensitivity, EVPI, EVII, strategy table, robustness) are currently UI/modal-dialog only; the clean path — since we own the source — is to add headless `[ExcelCommand]` entry points mirroring the existing `MC_RiskProfile_Auto`, then invoke + read them via `Application.Run`.
+- **Phase 3:** build/edit trees — write the model JSON into `_MC_Store` and trigger a re-render.
+
+## Architecture
+
+A separate server that reuses the patterns proven in `modelrisk-mcp` (xlwings bridge, dry-run-by-default safety on any future writes, packaging, MCP-registry flow). Decision analysis and Monte Carlo are distinct domains, so they ship as distinct servers.
+
+## Development
+
+```powershell
+uv sync --extra dev
+uv run pytest        # parser/roller + store-format tests (no Excel needed)
+```
+
+MIT licensed.

modelchoice_mcp-0.0.1/README.md

@@ -0,0 +1,48 @@
+# ModelChoice MCP
+
+**An open Model Context Protocol server for [Vose Software's ModelChoice](https://www.vosesoftware.com) — the decision-tree add-in for Excel.**
+
+A sibling to [`modelrisk-mcp`](https://github.com/vosesoftware/modelrisk-mcp): where that server brings Monte Carlo risk modelling into a conversation, this one brings **decision analysis** — building, reading, rolling back, and analysing decision trees in Excel.
+
+> **Status: `0.0.1` — Phase 1 MCP server (read-only).** Three tools (`list_trees`, `get_tree`, `roll_up`) over a proven read path. Building/analysis tools are on the roadmap below.
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `list_trees` | List the decision trees in a workbook with node-type counts. |
+| `get_tree` | Full structure of one tree — decision / chance / terminal nodes, branches, probabilities, values. |
+| `roll_up` | Roll the tree back to its expected values and **optimal policy** — the decision recommendation, in plain English. |
+| `verify_rollback` | Cross-check our rollback against the `MC_V_<id>` cells ModelChoice itself wrote — a correctness guarantee when the tree has been rendered. |
+
+Run it: `uv run python -m modelchoice_mcp` (stdio), or wire `modelchoice-mcp` into Claude Desktop like any MCP server.
+
+## How it works
+
+ModelChoice is a C# .NET (Excel-DNA) add-in. Unlike ModelRisk it exposes **no COM object model and no compute worksheet functions** — but it persists the *entire* decision tree as JSON in a very-hidden worksheet (`_MC_Store`), and the rollback logic is fully captured in that model. So this server can:
+
+- **Read** every tree in a workbook by reassembling the `_MC_Store` payload (chunked across columns, v2-envelope or v1-legacy format) and parsing the model JSON.
+- **Roll back** each tree to its expected values and **optimal policy** in pure Python — reproducing ModelChoice's own rollback (terminal payoff = accumulated branch values; chance = auto-normalized probability-weighted EV; decision = max/min by `Maximize`). **No add-in needs to be loaded** — it reads the saved model directly.
+
+The Python roller is validated against ModelChoice's own authoritative C# test (`Model_Validate_Compile_Rollback_Works`): a decision/chance tree that rolls back to EV 50 with the optimal option selected — and matches exactly.
+
+## Roadmap
+
+- **Phase 0 (done):** the read + rollback engine — parse `_MC_Store`, reconstruct each tree, roll back to EV + optimal policy. Validated against ModelChoice's own C# rollback test.
+- **Phase 1 (done):** the MCP server — `list_trees`, `get_tree`, `roll_up`, proven live against a real workbook.
+- **Phase 1b (done):** `verify_rollback` cross-checks our EVs against the `MC_V_<id>` named ranges; CI (ruff + mypy + pytest) and a tag-driven PyPI release pipeline; wheel + sdist build. *(First publish awaits a PyPI trusted-publisher; the live `MC_V_` cross-check awaits a real rendered tree.)*
+- **Phase 2:** drive analyses. ModelChoice's analyses (sensitivity, EVPI, EVII, strategy table, robustness) are currently UI/modal-dialog only; the clean path — since we own the source — is to add headless `[ExcelCommand]` entry points mirroring the existing `MC_RiskProfile_Auto`, then invoke + read them via `Application.Run`.
+- **Phase 3:** build/edit trees — write the model JSON into `_MC_Store` and trigger a re-render.
+
+## Architecture
+
+A separate server that reuses the patterns proven in `modelrisk-mcp` (xlwings bridge, dry-run-by-default safety on any future writes, packaging, MCP-registry flow). Decision analysis and Monte Carlo are distinct domains, so they ship as distinct servers.
+
+## Development
+
+```powershell
+uv sync --extra dev
+uv run pytest        # parser/roller + store-format tests (no Excel needed)
+```
+
+MIT licensed.

modelchoice_mcp-0.0.1/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "modelchoice-mcp"
+version = "0.0.1"
+description = "An open Model Context Protocol server for Vose Software's ModelChoice decision-tree add-in for Excel."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "Vose Software" }]
+dependencies = [
+    "mcp>=1.2.0",
+    "pydantic>=2.0",
+    "xlwings>=0.30",
+]
+
+[project.scripts]
+modelchoice-mcp = "modelchoice_mcp.__main__:main"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+    "ruff>=0.6",
+    "mypy>=1.10",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/modelchoice_mcp"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+
+[tool.ruff]
+line-length = 100
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "N", "RUF"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+files = ["src"]

modelchoice_mcp-0.0.1/src/modelchoice_mcp/__init__.py

@@ -0,0 +1,4 @@
+"""ModelChoice MCP — an open Model Context Protocol server for Vose
+Software's ModelChoice decision-tree add-in for Excel."""
+
+__version__ = "0.0.1"

modelchoice_mcp-0.0.1/src/modelchoice_mcp/__main__.py

@@ -0,0 +1,40 @@
+"""ModelChoice MCP server entrypoint.
+
+    python -m modelchoice_mcp                              # stdio (default)
+    python -m modelchoice_mcp --transport=streamable-http  # HTTP, 127.0.0.1:8000
+    python -m modelchoice_mcp --transport=sse --port=9000
+"""
+
+from __future__ import annotations
+
+import argparse
+from typing import Literal, cast
+
+from modelchoice_mcp.server import mcp
+
+Transport = Literal["stdio", "streamable-http", "sse"]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="modelchoice-mcp")
+    parser.add_argument(
+        "--transport",
+        choices=["stdio", "streamable-http", "sse"],
+        default="stdio",
+        help="MCP transport (default: stdio).",
+    )
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+
+    transport = cast(Transport, args.transport)
+    if transport == "stdio":
+        mcp.run(transport="stdio")
+    else:
+        mcp.settings.host = args.host
+        mcp.settings.port = args.port
+        mcp.run(transport=transport)
+
+
+if __name__ == "__main__":
+    main()

modelchoice_mcp-0.0.1/src/modelchoice_mcp/bridge.py

@@ -0,0 +1,135 @@
+"""Excel bridge for ModelChoice — read decision trees from a workbook.
+
+Phase 0 is read-only. ModelChoice exposes no COM object model, but the
+full tree model is persisted as JSON in the very-hidden ``_MC_Store``
+worksheet (see :mod:`modelchoice_mcp.store`). We read that sheet's row-1
+content (chunked across columns) via xlwings, parse each tree, and roll
+it back in pure Python — so the add-in need not even be loaded.
+
+The bridge deliberately does NOT unhide or modify ``_MC_Store``; it
+reads cell values only.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from modelchoice_mcp.store import STORE_SHEET_NAME, parse_store, reassemble_chunks
+from modelchoice_mcp.tree import DecisionTree, RollupResult, parse_model, rollup
+
+
+class ModelChoiceNotFoundError(RuntimeError):
+    """The workbook contains no ModelChoice tree store (`_MC_Store`)."""
+
+
+class ExcelNotRunningError(RuntimeError):
+    """No running Excel instance could be attached."""
+
+
+class ModelChoiceBridge:
+    """Attach to a running Excel and read ModelChoice trees from a
+    workbook's very-hidden ``_MC_Store`` sheet."""
+
+    def __init__(self) -> None:
+        self._xw: Any = None
+
+    def _load_xw(self) -> Any:
+        if self._xw is None:
+            import xlwings  # imported lazily so the package is importable without Excel
+
+            self._xw = xlwings
+        return self._xw
+
+    def _book(self, workbook: str | None) -> Any:
+        xw = self._load_xw()
+        app = xw.apps.active
+        if app is None:
+            raise ExcelNotRunningError(
+                "No running Excel instance found. Open the workbook in Excel first."
+            )
+        if workbook is None:
+            return app.books.active
+        for b in app.books:
+            if b.name == workbook:
+                return b
+        raise ModelChoiceNotFoundError(f"Workbook {workbook!r} is not open.")
+
+    def read_store_raw(self, workbook: str | None = None) -> str:
+        """Return the reassembled ``_MC_Store`` A1 payload, or '' if the
+        sheet is absent."""
+        book = self._book(workbook)
+        try:
+            sheet = book.sheets[STORE_SHEET_NAME]
+        except Exception:
+            return ""
+        # Read row 1 across enough columns to cover the chunk limit.
+        row = sheet.range((1, 1), (1, 100)).value
+        if not isinstance(row, list):
+            row = [row]
+        cells = [None if v is None else str(v) for v in row]
+        return reassemble_chunks(cells)
+
+    def list_trees(self, workbook: str | None = None) -> dict[str, str]:
+        """Return a mapping of tree-sheet-name → model JSON string."""
+        raw = self.read_store_raw(workbook)
+        if not raw:
+            raise ModelChoiceNotFoundError(
+                "Workbook has no ModelChoice tree store (_MC_Store sheet)."
+            )
+        return parse_store(raw)
+
+    def get_tree(self, sheet_name: str | None = None, workbook: str | None = None) -> DecisionTree:
+        """Parse one tree (by its sheet name, or the first/only tree)."""
+        trees = self.list_trees(workbook)
+        if not trees:
+            raise ModelChoiceNotFoundError("No trees stored in this workbook.")
+        if sheet_name is None:
+            sheet_name = next(iter(trees))
+        if sheet_name not in trees:
+            raise ModelChoiceNotFoundError(
+                f"Tree {sheet_name!r} not found. Available: {', '.join(trees)}."
+            )
+        return parse_model(trees[sheet_name])
+
+    def roll_up(self, sheet_name: str | None = None, workbook: str | None = None) -> RollupResult:
+        """Read a tree and return its rolled-back EV + optimal policy."""
+        return rollup(self.get_tree(sheet_name, workbook))
+
+    def read_node_values(self, workbook: str | None = None) -> dict[str, float]:
+        """Read the rolled-back expected values ModelChoice itself wrote
+        into the ``MC_V_<nodeId>`` named ranges on the rendered tree
+        sheet(s). Returns ``{nodeId: value}``. These are the add-in's own
+        rollback numbers — comparing them to our Python rollback proves
+        the two agree. Returns an empty dict if the tree hasn't been
+        rendered (named ranges only exist after a render)."""
+        book = self._book(workbook)
+        prefix = "MC_V_"
+        out: dict[str, float] = {}
+
+        name_objs: list[Any] = []
+        try:
+            name_objs.extend(list(book.names))
+        except Exception:
+            pass
+        for sht in book.sheets:
+            try:
+                name_objs.extend(list(sht.names))
+            except Exception:
+                pass
+
+        for nm in name_objs:
+            try:
+                full = str(nm.name)  # may be "MC_V_D" or "Sheet!MC_V_D"
+            except Exception:
+                continue
+            idx = full.find(prefix)
+            if idx < 0:
+                continue
+            node_id = full[idx + len(prefix):]
+            try:
+                val = nm.refers_to_range.value
+            except Exception:
+                continue
+            if isinstance(val, (int, float)) and not isinstance(val, bool):
+                out[node_id] = float(val)
+        return out

modelchoice_mcp-0.0.1/src/modelchoice_mcp/schemas.py

@@ -0,0 +1,95 @@
+"""Pydantic response schemas for the MCP tools."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+
+class BranchView(BaseModel):
+    name: str
+    child_id: str
+    value: float = Field(description="Branch/option value added along the path.")
+    probability: float | None = Field(
+        default=None, description="Probability (chance branches only; null for decision options)."
+    )
+
+
+class NodeView(BaseModel):
+    id: str
+    name: str
+    kind: str = Field(description="'decision', 'chance', or 'terminal'.")
+    value: float = Field(default=0.0, description="Terminal node's own value (0 otherwise).")
+    branches: list[BranchView] = Field(default_factory=list)
+
+
+class TreeSummary(BaseModel):
+    name: str = Field(description="Tree sheet name (e.g. 'MC_Tree_1').")
+    model_name: str
+    root_id: str
+    root_name: str
+    node_count: int
+    decision_count: int
+    chance_count: int
+    terminal_count: int
+
+
+class TreeList(BaseModel):
+    workbook: str | None = None
+    count: int
+    trees: list[TreeSummary]
+
+
+class TreeStructure(BaseModel):
+    name: str
+    model_name: str
+    root_id: str
+    maximize: bool = Field(description="True = the tree maximizes EV; False = minimizes.")
+    node_count: int
+    nodes: list[NodeView]
+
+
+class NodeResultView(BaseModel):
+    id: str
+    name: str
+    kind: str
+    expected_value: float
+    optimal_branch_name: str | None = Field(
+        default=None, description="At a decision node, the option chosen by rollback."
+    )
+
+
+class RollupResponse(BaseModel):
+    name: str
+    model_name: str
+    maximize: bool
+    expected_value: float = Field(description="Rolled-back expected value at the root.")
+    optimal_path: list[str] = Field(
+        description="The decisions taken under the optimal policy, from the root."
+    )
+    recommendation: str = Field(description="Plain-English decision recommendation.")
+    nodes: list[NodeResultView]
+
+
+class NodeDiff(BaseModel):
+    node_id: str
+    name: str
+    computed: float = Field(description="Our Python rollback EV for this node.")
+    cell: float = Field(description="The MC_V_<nodeId> value ModelChoice wrote.")
+    diff: float = Field(description="computed - cell.")
+
+
+class RollbackVerification(BaseModel):
+    """Cross-check of our Python rollback against the EVs ModelChoice
+    itself wrote into the MC_V_<nodeId> named ranges."""
+
+    name: str
+    rendered: bool = Field(
+        description="True if the tree has MC_V_ cells (i.e. it has been rendered by the add-in)."
+    )
+    compared_count: int = Field(description="Nodes present in both our rollback and the cells.")
+    matches: int
+    max_abs_diff: float = Field(description="Largest |computed - cell| across compared nodes.")
+    mismatches: list[NodeDiff] = Field(
+        default_factory=list, description="Nodes whose values differ beyond the tolerance."
+    )
+    verdict: str

modelchoice_mcp-0.0.1/src/modelchoice_mcp/server.py

@@ -0,0 +1,29 @@
+"""FastMCP server entrypoint.
+
+Constructs the ``mcp`` instance and triggers tool registration by
+importing ``modelchoice_mcp.tools`` (the tools attach via the
+``@mcp.tool`` decorator side-effect). Read-only in Phase 0/1.
+"""
+
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP
+
+from modelchoice_mcp import __version__
+
+mcp = FastMCP(
+    name="modelchoice-mcp",
+    instructions=(
+        "ModelChoice MCP exposes Vose Software's ModelChoice decision-tree "
+        "add-in for Excel. It reads decision trees stored in a workbook and "
+        "rolls them back to expected values and the optimal policy — the "
+        "decision recommendation — without needing the add-in loaded. Use "
+        "list_trees to discover trees, get_tree for structure, and roll_up "
+        "for the recommendation."
+    ),
+)
+
+# Side-effect import registers every @mcp.tool. Must come after `mcp`.
+from modelchoice_mcp import tools  # noqa: E402, F401
+
+__all__ = ["__version__", "mcp"]

modelchoice_mcp-0.0.1/src/modelchoice_mcp/store.py

@@ -0,0 +1,69 @@
+"""Read ModelChoice's per-workbook tree storage.
+
+ModelChoice persists every decision tree as JSON in a *very hidden*
+worksheet named ``_MC_Store`` (see ``TreeJsonStore.cs`` in the add-in).
+The payload lives in row 1, chunked across columns A1, B1, C1, … when it
+exceeds Excel's ~32k-character cell limit. The reassembled string is a
+v2 envelope::
+
+    {"_v": 2, "trees": {"<sheetName>": "<model-json-string>", ...}}
+
+where each *value* is itself a JSON string (the serialized
+``DecisionTreeModel``). A v1 legacy form stored the raw model JSON
+directly (detected by a top-level ``RootId``), keyed as ``MC_TreeView``.
+
+This module is pure: it turns the raw cell string(s) into a mapping of
+sheet-name → model-JSON-string. The Excel/COM reading lives in the
+bridge so this stays unit-testable without Excel.
+"""
+
+from __future__ import annotations
+
+import json
+
+STORE_SHEET_NAME = "_MC_Store"
+_LEGACY_TREE_KEY = "MC_TreeView"
+
+
+def parse_store(raw: str) -> dict[str, str]:
+    """Parse the reassembled ``_MC_Store`` A1 payload into a mapping of
+    sheet name → model JSON string. Mirrors ``TreeJsonStore.ParseStorageFormat``.
+
+    Returns an empty dict for empty input.
+    """
+    if not raw or not raw.strip():
+        return {}
+
+    try:
+        root = json.loads(raw)
+    except json.JSONDecodeError:
+        # Not valid JSON at all — treat the whole thing as a single v1 model.
+        return {_LEGACY_TREE_KEY: raw}
+
+    if isinstance(root, dict):
+        # v2 envelope: {"_v": >=2, "trees": {...}}
+        v = root.get("_v")
+        trees = root.get("trees")
+        if isinstance(v, int) and v >= 2 and isinstance(trees, dict):
+            return {
+                k: (val if isinstance(val, str) else json.dumps(val))
+                for k, val in trees.items()
+            }
+
+        # v1: raw model JSON (has a RootId / rootId but no envelope).
+        if "RootId" in root or "rootId" in root:
+            return {_LEGACY_TREE_KEY: raw}
+
+    # Fallback: opaque content, treat as a single model.
+    return {_LEGACY_TREE_KEY: raw}
+
+
+def reassemble_chunks(cells: list[str | None]) -> str:
+    """Reassemble the chunked A1, B1, C1, … payload. Stops at the first
+    empty cell. Mirrors ``TreeJsonStore.ReadChunkedContent``."""
+    parts: list[str] = []
+    for c in cells:
+        if c is None or c == "":
+            break
+        parts.append(c)
+    return "".join(parts)