celltype-cli 0.2.0__tar.gz → 0.2.1__tar.gz

{celltype_cli-0.2.0 → celltype_cli-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celltype-cli
-Version: 0.2.0
+Version: 0.2.1
 Summary: CellType CLI — An autonomous agent for drug discovery research
 Author: CellType Inc.
 License: MIT
@@ -16,6 +16,7 @@ Requires-Dist: numpy>=1.24
 Requires-Dist: openai>=1.0
 Requires-Dist: pandas>=2.0
 Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: pydantic>=2.0
 Requires-Dist: python-dotenv>=1.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=13.0
@@ -76,7 +77,7 @@ Description-Content-Type: text/markdown
 
 > **v0.2.0 is out** — Offload GPU-accelerated tools to CellType Cloud with no additional setup. ESMFold, Boltz-2, RFdiffusion, ProteinMPNN, and more. Update now:
 > ```bash
-> pip install --upgrade celltype-cli
+> curl -fsSL https://raw.githubusercontent.com/celltype/celltype-agent/main/install.sh | bash
 > ```
 
 An autonomous agent for drug discovery research. Like Claude Code, but for biology.
@@ -114,10 +115,10 @@ CellType CLI achieves **90% accuracy** on [BixBench-Verified-50](https://hugging
 ### Quick install
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/celltype/cli/main/install.sh | bash
+curl -fsSL https://raw.githubusercontent.com/celltype/celltype-agent/main/install.sh | bash
 ```
 
-Detects Python 3.10+, installs via `pipx` or `pip`, and launches an interactive setup wizard.
+Detects Python 3.10+, installs the latest `celltype-cli` release from PyPI via `uv`, `pipx`, or `pip`, and launches the interactive setup wizard.
 
 ### Manual install
 

{celltype_cli-0.2.0 → celltype_cli-0.2.1}/README.md

@@ -2,7 +2,7 @@
 
 > **v0.2.0 is out** — Offload GPU-accelerated tools to CellType Cloud with no additional setup. ESMFold, Boltz-2, RFdiffusion, ProteinMPNN, and more. Update now:
 > ```bash
-> pip install --upgrade celltype-cli
+> curl -fsSL https://raw.githubusercontent.com/celltype/celltype-agent/main/install.sh | bash
 > ```
 
 An autonomous agent for drug discovery research. Like Claude Code, but for biology.
@@ -40,10 +40,10 @@ CellType CLI achieves **90% accuracy** on [BixBench-Verified-50](https://hugging
 ### Quick install
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/celltype/cli/main/install.sh | bash
+curl -fsSL https://raw.githubusercontent.com/celltype/celltype-agent/main/install.sh | bash
 ```
 
-Detects Python 3.10+, installs via `pipx` or `pip`, and launches an interactive setup wizard.
+Detects Python 3.10+, installs the latest `celltype-cli` release from PyPI via `uv`, `pipx`, or `pip`, and launches the interactive setup wizard.
 
 ### Manual install
 

{celltype_cli-0.2.0 → celltype_cli-0.2.1}/install.sh

@@ -1,10 +1,9 @@
 #!/usr/bin/env bash
 # celltype-cli — One-liner installer
-# Usage: curl -fsSL https://raw.githubusercontent.com/celltype/cli/main/install.sh | bash
+# Usage: curl -fsSL https://raw.githubusercontent.com/celltype/celltype-agent/main/install.sh | bash
 set -euo pipefail
 
 PACKAGE="celltype-cli"
-REPO_URL="git+https://github.com/celltype/cli.git"
 MIN_PYTHON="3.10"
 
 # ── Helpers ────────────────────────────────────────────────────
@@ -46,15 +45,15 @@ esac
 
 # ── Install package ────────────────────────────────────────────
 
-INSTALL_SPEC="${PACKAGE} @ ${REPO_URL}"
+INSTALL_SPEC="${PACKAGE}"
 
 if command -v uv >/dev/null 2>&1; then
-    info "Installing ${PACKAGE} via uv..."
-    uv tool install "$INSTALL_SPEC" || uv tool install --force "$INSTALL_SPEC"
+    info "Installing latest ${PACKAGE} from PyPI via uv..."
+    uv tool install "$INSTALL_SPEC" || uv tool install --upgrade "$INSTALL_SPEC" || uv tool install --force "$INSTALL_SPEC"
     ok "Installed with uv"
 elif command -v pipx >/dev/null 2>&1; then
-    info "Installing ${PACKAGE} via pipx..."
-    pipx install "$REPO_URL" || pipx install --force "$REPO_URL"
+    info "Installing latest ${PACKAGE} from PyPI via pipx..."
+    pipx install "$INSTALL_SPEC" || pipx upgrade "$PACKAGE" || pipx install --force "$INSTALL_SPEC"
     ok "Installed with pipx"
 else
     warn "uv/pipx not found — falling back to pip install --user"
@@ -83,7 +82,16 @@ ok "ct $(ct --version 2>/dev/null || echo '(installed)')"
 
 # ── Run setup wizard ───────────────────────────────────────────
 
-info ""
-info "Running setup wizard..."
-info ""
-ct setup
+if "$PYTHON" -c 'import os; fd = os.open("/dev/tty", os.O_RDONLY); os.close(fd)' 2>/dev/null; then
+    info ""
+    info "Running setup wizard..."
+    info ""
+    # When installed via `curl ... | bash`, stdin is the download pipe rather
+    # than the user's keyboard. Reattach setup to the controlling terminal so
+    # interactive prompts and masked input work normally.
+    ct setup < /dev/tty
+else
+    warn ""
+    warn "Skipping interactive setup because no terminal is available."
+    warn "Run: ct setup"
+fi

{celltype_cli-0.2.0 → celltype_cli-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "celltype-cli"
-version = "0.2.0"
+version = "0.2.1"
 description = "CellType CLI — An autonomous agent for drug discovery research"
 readme = "README.md"
 license = {text = "MIT"}
@@ -29,6 +29,7 @@ dependencies = [
     "markdown>=3.5",
     "nbformat>=5.7",
     "pyyaml>=6.0",
+    "pydantic>=2.0",
 ]
 
 [project.optional-dependencies]

{celltype_cli-0.2.0 → celltype_cli-0.2.1}/src/ct/agent/config.py

@@ -33,7 +33,6 @@ DEFAULTS = {
     "llm.api_key": None,
     "llm.openai_api_key": None,
     "llm.temperature": 0.1,
-
     "data.base": str(CONFIG_DIR / "data"),
     "data.depmap": None,
     "data.prism": None,

{celltype_cli-0.2.0 → celltype_cli-0.2.1}/src/ct/agent/mcp_server.py

@@ -71,6 +71,14 @@ _PY_TYPE_MAP = {
 }
 
 
+def _is_json_schema(parameters: dict) -> bool:
+    return (
+        isinstance(parameters, dict)
+        and parameters.get("type") == "object"
+        and isinstance(parameters.get("properties"), dict)
+    )
+
+
 def _params_to_json_schema(parameters: dict) -> dict:
     """Convert a ct tool parameters dict to a JSON Schema object.
 
@@ -81,6 +89,9 @@ def _params_to_json_schema(parameters: dict) -> dict:
     if not parameters:
         return {"type": "object", "properties": {}}
 
+    if _is_json_schema(parameters):
+        return parameters
+
     properties = {}
     for name, desc in parameters.items():
         # Extract type hint from description if present (e.g., "gene name (str)")
@@ -110,30 +121,30 @@ def _make_tool_handler(tool_obj, session):
         call_args["_session"] = session
         call_args["_prior_results"] = {}
 
-        # Coerce string values to numeric types when they look like numbers.
-        # MCP sends all parameters as strings, but tools often expect int/float.
-        for key, val in list(call_args.items()):
-            if key.startswith("_"):
-                continue
-            if isinstance(val, str):
-                # Try int first, then float
-                try:
-                    call_args[key] = int(val)
+        # Legacy flat ct manifests describe every parameter as a string, so keep
+        # backwards-compatible coercion there. Structured JSON Schema tools should
+        # preserve the exact payload emitted by the SDK.
+        if not _is_json_schema(getattr(tool_obj, "parameters", {})):
+            for key, val in list(call_args.items()):
+                if key.startswith("_"):
                     continue
-                except ValueError:
-                    pass
-                try:
-                    call_args[key] = float(val)
-                    continue
-                except ValueError:
-                    pass
-                # Boolean coercion
-                if val.lower() in ("true", "false"):
-                    call_args[key] = val.lower() == "true"
+                if isinstance(val, str):
+                    try:
+                        call_args[key] = int(val)
+                        continue
+                    except ValueError:
+                        pass
+                    try:
+                        call_args[key] = float(val)
+                        continue
+                    except ValueError:
+                        pass
+                    if val.lower() in ("true", "false"):
+                        call_args[key] = val.lower() == "true"
 
         try:
             # Route GPU tools through compute router
-            if getattr(tool_obj, "requires_gpu", False):
+            if getattr(tool_obj, "requires_gpu", False) or getattr(tool_obj, "cpu_only", False):
                 from ct.cloud.router import ComputeRouter
                 router = ComputeRouter(config=getattr(session, "config", None))
                 result = await asyncio.to_thread(router.route, tool_obj, **call_args)

{celltype_cli-0.2.0 → celltype_cli-0.2.1}/src/ct/cli.py

@@ -423,11 +423,13 @@ def setup_gpu_cmd():
 
 def _prompt_api_key() -> str:
     """Prompt user for API key with masked input."""
-    import getpass
+    from prompt_toolkit import prompt as pt_prompt
+
     console.print("  Get your key at: [link=https://console.anthropic.com/settings/keys]console.anthropic.com/settings/keys[/link]")
     console.print()
+    console.print("  [dim]Pasted/typed characters will appear as *[/dim]")
     try:
-        key = getpass.getpass("  Enter your Anthropic API key: ")
+        key = pt_prompt("  Enter your Anthropic API key: ", is_password=True)
     except (EOFError, KeyboardInterrupt):
         console.print("\n  [dim]Setup cancelled.[/dim]")
         raise typer.Exit()
@@ -492,16 +494,24 @@ def tool_list(
     ensure_loaded()
 
     if gpu:
-        # Show GPU tools with hardware compatibility
+        # Show GPU tools with hardware compatibility and Docker image status
+        import subprocess as _sp
+        import json as _json
         from ct.cloud.router import _detect_local_gpu_info
 
         gpus = _detect_local_gpu_info()
         best_gpu = max(gpus, key=lambda g: g.vram_mb) if gpus else None
 
+        try:
+            docker_ok = _sp.run(["docker", "info"], capture_output=True, timeout=5).returncode == 0
+        except Exception:
+            docker_ok = False
+
         table = Table(title="GPU/High-Memory Tools")
         table.add_column("Tool", style="cyan")
         table.add_column("Type")
         table.add_column("Requirement")
+        table.add_column("Pulled", style="bold")
         table.add_column("Local", style="bold")
         table.add_column("Description")
 
@@ -523,7 +533,24 @@ def tool_list(
                 else:
                     compat = "[red]no GPU[/red]"
 
-            table.add_row(tool.name, tool_type, req, compat, tool.description[:60])
+            pulled = "-"
+            if docker_ok and getattr(tool, "docker_image", None):
+                try:
+                    res = _sp.run(
+                        ["docker", "image", "inspect", "--format",
+                         "{{.Size}}", tool.docker_image],
+                        capture_output=True, text=True, timeout=10,
+                    )
+                    if res.returncode == 0:
+                        size_bytes = int(res.stdout.strip())
+                        size_gb = size_bytes / (1024 ** 3)
+                        pulled = f"[green]✓ {size_gb:.1f}GB[/green]"
+                    else:
+                        pulled = "[red]✗[/red]"
+                except Exception:
+                    pulled = "-"
+
+            table.add_row(tool.name, tool_type, req, pulled, compat, tool.description[:60])
 
         console.print(table)
         if best_gpu:
@@ -543,6 +570,120 @@ def tool_list(
         )
 
 
+def _pull_colabfold_databases(console):
+    """Download ColabFold databases (UniRef30 + EnvDB) for local MSA search."""
+    import shutil
+    from pathlib import Path
+
+    home = Path.home()
+    db_dir = Path(os.environ.get("COLABFOLD_DB", home / ".cache" / "colabfold_db"))
+    uniref_ready = db_dir / "UNIREF30_READY"
+    envdb_ready = db_dir / "COLABDB_READY"
+
+    if uniref_ready.exists() and envdb_ready.exists():
+        size = sum(f.stat().st_size for f in db_dir.rglob("*") if f.is_file()) / (1024**3)
+        console.print(f"[green]ColabFold databases already downloaded at {db_dir} ({size:.0f}GB)[/green]")
+        return
+
+    console.print(f"\n[bold]MSA-Search requires ColabFold databases for local execution.[/bold]")
+    console.print(f"  Location: {db_dir}")
+    console.print(f"  Download: ~220GB compressed, ~500GB extracted")
+    console.print(f"  Databases: UniRef30 2302 + ColabFold EnvDB 202108\n")
+
+    if not shutil.which("mmseqs"):
+        console.print("[yellow]Installing mmseqs2...[/yellow]")
+        import subprocess
+        subprocess.check_call(
+            "cd /tmp && wget -q https://mmseqs.com/latest/mmseqs-linux-avx2.tar.gz "
+            "&& tar xzf mmseqs-linux-avx2.tar.gz "
+            "&& sudo cp mmseqs/bin/mmseqs /usr/local/bin/ "
+            "&& rm -rf mmseqs mmseqs-linux-avx2.tar.gz",
+            shell=True,
+        )
+        console.print("[green]mmseqs2 installed.[/green]")
+
+    download_tool = None
+    for tool in ["aria2c", "curl", "wget"]:
+        if shutil.which(tool):
+            download_tool = tool
+            break
+    if not download_tool:
+        console.print("[red]No download tool found. Install aria2c, curl, or wget.[/red]")
+        return
+
+    db_dir.mkdir(parents=True, exist_ok=True)
+    import subprocess
+
+    UNIREF = "uniref30_2302"
+    ENVDB = "colabfold_envdb_202108"
+
+    def _download(url, output):
+        console.print(f"  Downloading {Path(output).name}...")
+        if download_tool == "aria2c":
+            subprocess.check_call(
+                ["aria2c", "--max-connection-per-server=8", "--allow-overwrite=true",
+                 "-o", Path(output).name, "-d", str(Path(output).parent), url])
+        elif download_tool == "curl":
+            subprocess.check_call(["curl", "-L", "-o", str(output), url])
+        else:
+            subprocess.check_call(["wget", "-O", str(output), url])
+
+    os.environ["MMSEQS_FORCE_MERGE"] = "1"
+
+    if not uniref_ready.exists():
+        tarball = db_dir / f"{UNIREF}.tar.gz"
+        if not tarball.exists():
+            _download(
+                f"https://opendata.mmseqs.org/colabfold/{UNIREF}.db.tar.gz",
+                str(tarball))
+        console.print(f"  Extracting {UNIREF} (this takes ~15 minutes)...")
+        subprocess.check_call(["tar", "-xzf", str(tarball)], cwd=str(db_dir))
+
+        tax_tarball = db_dir / f"{UNIREF}_newtaxonomy.tar.gz"
+        if not tax_tarball.exists():
+            _download(
+                f"https://opendata.mmseqs.org/colabfold/{UNIREF}_newtaxonomy.tar.gz",
+                str(tax_tarball))
+        subprocess.check_call(["tar", "-xzf", str(tax_tarball)], cwd=str(db_dir))
+
+        mapping = db_dir / f"{UNIREF}_db_mapping"
+        if mapping.exists():
+            try:
+                subprocess.check_call(
+                    ["mmseqs", "createbintaxmapping", str(mapping), str(mapping) + ".bin"])
+                os.replace(str(mapping) + ".bin", str(mapping))
+            except Exception:
+                pass
+            for src, dst in [
+                (f"{UNIREF}_db_mapping", f"{UNIREF}_db.idx_mapping"),
+                (f"{UNIREF}_db_taxonomy", f"{UNIREF}_db.idx_taxonomy"),
+            ]:
+                src_path = db_dir / src
+                dst_path = db_dir / dst
+                if src_path.exists() and not dst_path.exists():
+                    dst_path.symlink_to(src_path.name)
+
+        uniref_ready.touch()
+        tarball.unlink(missing_ok=True)
+        tax_tarball.unlink(missing_ok=True)
+        console.print(f"[green]  UniRef30 ready.[/green]")
+
+    if not envdb_ready.exists():
+        tarball = db_dir / f"{ENVDB}.tar.gz"
+        if not tarball.exists():
+            _download(
+                f"https://opendata.mmseqs.org/colabfold/{ENVDB}.db.tar.gz",
+                str(tarball))
+        console.print(f"  Extracting {ENVDB} (this takes ~20 minutes)...")
+        subprocess.check_call(["tar", "-xzf", str(tarball)], cwd=str(db_dir))
+        envdb_ready.touch()
+        tarball.unlink(missing_ok=True)
+        console.print(f"[green]  ColabFold EnvDB ready.[/green]")
+
+    console.print(f"\n[green bold]ColabFold databases ready at {db_dir}[/green bold]")
+    console.print("MSA-Search will use local MMseqs2 for fast, reliable homology search.")
+
+
 @tool_app.command("pull")
 def tool_pull(
     tool_name: str = typer.Argument(..., help="Tool name (e.g., structure.esmfold)"),
@@ -626,10 +767,14 @@ def tool_pull(
             raise typer.Exit(code=1)
         console.print(f"[green]Built {docker_image}[/green]")
 
-    # Step 2: Pre-download weights by running container with cache mounts
-    # This triggers the first-run weight download inside the container
+    # Step 2: Pre-download weights / databases
     compute = config.get("compute", {})
     cpu_only = compute.get("cpu_only", False) or not compute.get("requires_gpu", True)
+
+    if tool_name == "genomics.msa_search":
+        _pull_colabfold_databases(console)
+        return
+
     if cpu_only:
         console.print(f"[green]{display_name} is CPU-only, no weights to download.[/green]")
         return
@@ -691,108 +836,6 @@ def tool_pull(
             console.print(f"[green]{display_name} image built. Weights will download on first real use.[/green]")
 
 
-@tool_app.command("build")
-def tool_build(
-    tool_name: str = typer.Argument(..., help="Tool name (e.g., structure.esmfold)"),
-):
-    """Build a Docker image for a GPU tool from the manifest."""
-    from ct.cloud.manifest import get_tool_config
-    from ct.cloud.image_builder import generate_dockerfile
-
-    config = get_tool_config(tool_name)
-    if not config:
-        console.print(f"[red]Tool '{tool_name}' not found in manifest.[/red]")
-        raise typer.Exit(code=1)
-
-    display_name = config.get("display_name", tool_name)
-    docker_image = config.get("docker_image", f"celltype/{tool_name.split('.')[-1]}:latest")
-
-    console.print(f"[bold]Building Docker image for {display_name}...[/bold]")
-
-    # Generate Dockerfile
-    import tempfile
-    with tempfile.TemporaryDirectory() as tmpdir:
-        from pathlib import Path
-        tmpdir = Path(tmpdir)
-        dockerfile_content = generate_dockerfile(config)
-        (tmpdir / "Dockerfile").write_text(dockerfile_content)
-
-        # Copy entrypoint
-        entrypoint_src = Path(__file__).parent / "cloud" / "tool_entrypoint.py"
-        if entrypoint_src.exists():
-            import shutil
-            shutil.copy2(entrypoint_src, tmpdir / "tool_entrypoint.py")
-
-        # Create placeholder implementation
-        impl_key = tool_name.split(".")[-1]
-        (tmpdir / "implementation.py").write_text(
-            f'"""Placeholder implementation for {display_name}."""\n\n'
-            f'def run(**kwargs):\n'
-            f'    return {{"summary": "{display_name} placeholder"}}\n'
-        )
-
-        # Build
-        import subprocess
-        result = subprocess.run(
-            ["docker", "build", "-t", docker_image, "."],
-            cwd=tmpdir,
-            capture_output=True,
-            text=True,
-            timeout=600,
-        )
-
-        if result.returncode != 0:
-            console.print(f"[red]Build failed:[/red]\n{result.stderr[:500]}")
-            raise typer.Exit(code=1)
-
-        console.print(f"[green]Built {docker_image}[/green]")
-
-
-@tool_app.command("setup")
-def tool_setup(
-    tool_name: str = typer.Argument(..., help="Tool name (e.g., structure.esmfold)"),
-):
-    """Pull Docker image and download model weights for a GPU tool."""
-    from ct.cloud.manifest import get_tool_config
-
-    config = get_tool_config(tool_name)
-    if not config:
-        console.print(f"[red]Tool '{tool_name}' not found in manifest.[/red]")
-        raise typer.Exit(code=1)
-
-    display_name = config.get("display_name", tool_name)
-    docker_image = config.get("docker_image", "")
-
-    console.print(f"[bold]Setting up {display_name}...[/bold]")
-
-    # Step 1: Pull Docker image
-    if docker_image:
-        console.print(f"\n[bold]Step 1: Pulling Docker image {docker_image}...[/bold]")
-        import subprocess
-        result = subprocess.run(
-            ["docker", "pull", docker_image],
-            capture_output=True,
-            text=True,
-            timeout=600,
-        )
-        if result.returncode != 0:
-            console.print(f"[yellow]Warning: Could not pull {docker_image}. You may need to build it first.[/yellow]")
-        else:
-            console.print(f"[green]Pulled {docker_image}[/green]")
-
-    # Step 2: Download weights
-    console.print(f"\n[bold]Step 2: Downloading model weights...[/bold]")
-    from ct.cloud.weight_downloader import pull_tool_weights
-    result = pull_tool_weights(tool_name)
-
-    if "error" in result:
-        console.print(f"[red]{result['summary']}[/red]")
-        raise typer.Exit(code=1)
-
-    console.print(f"[green]{result['summary']}[/green]")
-    console.print(f"\n[bold green]{display_name} is ready![/bold green]")
-
-
 # ─── Knowledge subcommands ────────────────────────────────────
 
 knowledge_app = typer.Typer(help="Manage knowledge substrate, ingestion, and quality gates")

{celltype_cli-0.2.0 → celltype_cli-0.2.1}/src/ct/cloud/client.py

@@ -15,7 +15,8 @@ logger = logging.getLogger("ct.cloud.client")
 
 # Polling interval for job status
 JOB_POLL_INTERVAL = 2.0
-JOB_TIMEOUT = 600.0  # 10 minutes max
+# OpenFold3 and other large structure jobs can exceed 10 minutes end-to-end.
+JOB_TIMEOUT = 1800.0  # 30 minutes max
 
 
 class CloudClient:

{celltype_cli-0.2.0 → celltype_cli-0.2.1}/src/ct/cloud/local_runner.py

@@ -100,14 +100,7 @@ class LocalRunner:
         return None
 
     def _get_timeout(self, tool) -> int:
-        """Get per-tool timeout from manifest, with fallback."""
-        try:
-            from ct.cloud.manifest import get_tool_config
-            config = get_tool_config(tool.name)
-            if config:
-                return config.get("execution", {}).get("timeout_s", 600)
-        except Exception:
-            pass
+        """Get per-tool timeout. Default 600s for all tools."""
         return 600
 
     # Weight mounts are handled by _get_cache_mounts() which mounts
@@ -146,6 +139,11 @@ class LocalRunner:
             resolved.mkdir(parents=True, exist_ok=True)
             mounts.extend(["-v", f"{resolved}:{container_path}"])
 
+        # ColabFold databases for MSA search (read-only mount, don't create if missing)
+        colabfold_db = Path(os.environ.get("COLABFOLD_DB", home / ".cache" / "colabfold_db"))
+        if colabfold_db.exists() and colabfold_db.joinpath("uniref30_2302_db.dbtype").exists():
+            mounts.extend(["-v", f"{colabfold_db}:/vol/colabfold_db:ro"])
+
         return mounts
 
     def _get_gpu_flags(self, tool) -> list[str]:

{celltype_cli-0.2.0 → celltype_cli-0.2.1}/src/ct/cloud/structure_inputs.py

@@ -8,6 +8,7 @@ from typing import Any
 
 INLINE_FILE_ARG_NAMES = {
     "target_pdb",
+    "pdb_text",
     "backbone_pdb",
     "protein_pdb",
 }

{celltype_cli-0.2.0 → celltype_cli-0.2.1}/src/ct/tools/__init__.py

@@ -189,7 +189,7 @@ class ToolRegistry:
                 continue
             lines.append(f"\n## {cat}")
             for tool in cat_tools:
-                params = ", ".join(f"{k}: {v}" for k, v in tool.parameters.items())
+                params = _summarize_tool_parameters(tool.parameters)
                 lines.append(f"- **{tool.name}**({params}): {tool.description}")
                 if tool.usage_guide:
                     lines.append(f"  USE WHEN: {tool.usage_guide}")
@@ -210,6 +210,20 @@ class ToolRegistry:
 registry = ToolRegistry()
 
 
+def _summarize_tool_parameters(parameters: dict) -> str:
+    if not isinstance(parameters, dict):
+        return ""
+    if parameters.get("type") == "object" and isinstance(parameters.get("properties"), dict):
+        parts = []
+        required = set(parameters.get("required", []))
+        for name, spec in parameters["properties"].items():
+            type_name = spec.get("type", "any") if isinstance(spec, dict) else "any"
+            suffix = " [required]" if name in required else ""
+            parts.append(f"{name}: {type_name}{suffix}")
+        return ", ".join(parts)
+    return ", ".join(f"{k}: {v}" for k, v in parameters.items())
+
+
 # Import tool modules to trigger registration
 def _load_tools():
     """Import all tool modules to register them."""

celltype_cli-0.2.1/src/ct/tools/_schema_contract.py

@@ -0,0 +1,44 @@
+"""Shared schema and error helpers for structured GPU tools."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+
+class ToolInputModel(BaseModel):
+    """Base input model for structured GPU tools."""
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+
+class ToolOutputModel(BaseModel):
+    """Base output model for structured GPU tools."""
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ToolErrorModel(BaseModel):
+    """Structured tool error payload for agent-friendly failures."""
+
+    summary: str
+    error: str
+    isError: bool = True
+    detail: str | None = None
+
+    model_config = ConfigDict(extra="allow")
+
+
+def structured_error(summary: str, error: str, **extra: Any) -> dict[str, Any]:
+    payload = ToolErrorModel(summary=summary, error=error, **extra)
+    return payload.model_dump(exclude_none=True)
+
+
+def export_tool_contract(input_model: type[BaseModel], output_model: type[BaseModel]) -> dict[str, Any]:
+    """Expose JSON Schema for the current tool contract."""
+
+    return {
+        "input_schema": input_model.model_json_schema(),
+        "output_schema": output_model.model_json_schema(),
+    }