testmcpy 0.2.2__tar.gz → 0.2.4__tar.gz

{testmcpy-0.2.2/testmcpy.egg-info → testmcpy-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testmcpy
-Version: 0.2.2
+Version: 0.2.4
 Summary: A comprehensive testing framework for validating LLM tool calling capabilities with MCP services
 Author: Amin Ghadersohi
 License-Expression: Apache-2.0
@@ -42,26 +42,34 @@ Requires-Dist: types-pyyaml>=6.0.0; extra == "dev"
 Requires-Dist: types-requests>=2.28.0; extra == "dev"
 Provides-Extra: server
 Requires-Dist: fastapi<1.0.0,>=0.104.0; extra == "server"
-Requires-Dist: uvicorn<1.0.0,>=0.24.0; extra == "server"
-Requires-Dist: websockets<13.0,>=12.0; extra == "server"
+Requires-Dist: uvicorn[standard]<1.0.0,>=0.24.0; extra == "server"
+Requires-Dist: websockets<15.0,>=14.0; extra == "server"
 Provides-Extra: sdk
 Requires-Dist: claude-agent-sdk>=0.1.0; extra == "sdk"
 Provides-Extra: all
 Requires-Dist: fastapi<1.0.0,>=0.104.0; extra == "all"
-Requires-Dist: uvicorn<1.0.0,>=0.24.0; extra == "all"
-Requires-Dist: websockets<13.0,>=12.0; extra == "all"
+Requires-Dist: uvicorn[standard]<1.0.0,>=0.24.0; extra == "all"
+Requires-Dist: websockets<15.0,>=14.0; extra == "all"
 Requires-Dist: claude-agent-sdk>=0.1.0; extra == "all"
 Dynamic: license-file
 
-# testmcpy
+<p align="center">
+  <img src="docs/logos/logo.svg" alt="testmcpy logo" width="600">
+</p>
 
-**Test and benchmark LLMs with MCP tools in minutes.**
+<p align="center">
+  <strong>Test and benchmark LLMs with MCP tools in minutes.</strong>
+</p>
 
-A testing framework for validating how LLMs call tools via Model Context Protocol (MCP) - compare Claude, GPT-4, Llama, and other models' accuracy, cost, and performance.
+<p align="center">
+  A testing framework for validating how LLMs call tools via Model Context Protocol (MCP) - compare Claude, GPT-4, Llama, and other models' accuracy, cost, and performance.
+</p>
 
-[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
-[![PyPI](https://img.shields.io/badge/pypi-testmcpy-blue)](https://pypi.org/project/testmcpy/)
+<p align="center">
+  <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.9+-blue.svg" alt="Python 3.9+"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License"></a>
+  <a href="https://pypi.org/project/testmcpy/"><img src="https://img.shields.io/badge/pypi-testmcpy-blue" alt="PyPI"></a>
+</p>
 
 [Screenshot: CLI test runner with colorful progress bars and results]
 
@@ -121,6 +129,16 @@ Comprehensive validation out of the box:
 - **Optional web interface**: Visual tool explorer and interactive chat
 - **Real-time feedback**: Watch tests execute with live updates
 
+When you start testmcpy, you're greeted with a beautiful terminal interface:
+
+```
+  ▀█▀ █▀▀ █▀ ▀█▀ █▀▄▀█ █▀▀ █▀█ █▄█
+   █  ██▄ ▄█  █  █ ▀ █ █▄▄ █▀▀  █
+
+  🧪 Test  •  📊 Benchmark  •  ✓ Validate
+  MCP Testing Framework
+```
+
 [Screenshot: Split view of CLI and Web UI running the same test]
 
 ### YAML Test Definitions

{testmcpy-0.2.2 → testmcpy-0.2.4}/README.md

@@ -1,12 +1,20 @@
-# testmcpy
+<p align="center">
+  <img src="docs/logos/logo.svg" alt="testmcpy logo" width="600">
+</p>
 
-**Test and benchmark LLMs with MCP tools in minutes.**
+<p align="center">
+  <strong>Test and benchmark LLMs with MCP tools in minutes.</strong>
+</p>
 
-A testing framework for validating how LLMs call tools via Model Context Protocol (MCP) - compare Claude, GPT-4, Llama, and other models' accuracy, cost, and performance.
+<p align="center">
+  A testing framework for validating how LLMs call tools via Model Context Protocol (MCP) - compare Claude, GPT-4, Llama, and other models' accuracy, cost, and performance.
+</p>
 
-[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
-[![PyPI](https://img.shields.io/badge/pypi-testmcpy-blue)](https://pypi.org/project/testmcpy/)
+<p align="center">
+  <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.9+-blue.svg" alt="Python 3.9+"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License"></a>
+  <a href="https://pypi.org/project/testmcpy/"><img src="https://img.shields.io/badge/pypi-testmcpy-blue" alt="PyPI"></a>
+</p>
 
 [Screenshot: CLI test runner with colorful progress bars and results]
 
@@ -66,6 +74,16 @@ Comprehensive validation out of the box:
 - **Optional web interface**: Visual tool explorer and interactive chat
 - **Real-time feedback**: Watch tests execute with live updates
 
+When you start testmcpy, you're greeted with a beautiful terminal interface:
+
+```
+  ▀█▀ █▀▀ █▀ ▀█▀ █▀▄▀█ █▀▀ █▀█ █▄█
+   █  ██▄ ▄█  █  █ ▀ █ █▄▄ █▀▀  █
+
+  🧪 Test  •  📊 Benchmark  •  ✓ Validate
+  MCP Testing Framework
+```
+
 [Screenshot: Split view of CLI and Web UI running the same test]
 
 ### YAML Test Definitions

{testmcpy-0.2.2 → testmcpy-0.2.4}/pyproject.toml

@@ -88,7 +88,7 @@ testmcpy = [
 
 [project]
 name = "testmcpy"
-version = "0.2.2"
+version = "0.2.4"
 description = "A comprehensive testing framework for validating LLM tool calling capabilities with MCP services"
 authors = [{name = "Amin Ghadersohi"}]
 license = "Apache-2.0"
@@ -132,16 +132,16 @@ dev = [
 ]
 server = [
     "fastapi>=0.104.0,<1.0.0",
-    "uvicorn>=0.24.0,<1.0.0",
-    "websockets>=12.0,<13.0",
+    "uvicorn[standard]>=0.24.0,<1.0.0",
+    "websockets>=14.0,<15.0",
 ]
 sdk = [
     "claude-agent-sdk>=0.1.0",
 ]
 all = [
     "fastapi>=0.104.0,<1.0.0",
-    "uvicorn>=0.24.0,<1.0.0",
-    "websockets>=12.0,<13.0",
+    "uvicorn[standard]>=0.24.0,<1.0.0",
+    "websockets>=14.0,<15.0",
     "claude-agent-sdk>=0.1.0",
 ]
 

{testmcpy-0.2.2 → testmcpy-0.2.4}/testmcpy/cli.py

@@ -40,10 +40,23 @@ app = typer.Typer(
 console = Console()
 
 
+def print_logo():
+    """Print testmcpy ASCII logo."""
+    logo = """
+  [bold cyan]▀█▀ █▀▀ █▀ ▀█▀ █▀▄▀█ █▀▀ █▀█ █▄█[/bold cyan]
+  [bold cyan] █  ██▄ ▄█  █  █ ▀ █ █▄▄ █▀▀  █ [/bold cyan]
+
+  [dim]🧪 Test  •  📊 Benchmark  •  ✓ Validate[/dim]
+  [dim]MCP Testing Framework[/dim]
+"""
+    console.print(logo)
+
+
 def version_callback(value: bool):
     """Display version and exit."""
     if value:
-        console.print(f"[bold cyan]testmcpy[/bold cyan] version [green]{__version__}[/green]")
+        print_logo()
+        console.print(f"\n  Version: [green]{__version__}[/green]")
         raise typer.Exit()
 
 
@@ -1263,6 +1276,9 @@ def serve(
     This command starts a FastAPI server that serves a beautiful React-based UI
     for inspecting MCP tools, interactive chat, and test management.
     """
+    # Show logo
+    print_logo()
+
     # Show authentication steps
     console.print("\n[bold cyan]Authentication Setup[/bold cyan]")
     console.print("[dim]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/dim]")
@@ -1397,10 +1413,25 @@ def serve(
     if not no_browser:
         import threading
         import webbrowser
+        import requests
 
         def open_browser():
-            time.sleep(1.5)  # Wait for server to start
-            webbrowser.open(f"http://{host}:{port}")
+            # Wait for server to be ready by checking health endpoint
+            url = f"http://{host}:{port}/"
+            max_attempts = 30
+            for i in range(max_attempts):
+                try:
+                    response = requests.get(url, timeout=1)
+                    if response.status_code == 200:
+                        # Server is ready
+                        webbrowser.open(url)
+                        return
+                except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
+                    pass
+                time.sleep(0.2)  # Wait 200ms between attempts
+
+            # If server didn't start after max attempts, open anyway
+            webbrowser.open(url)
 
         threading.Thread(target=open_browser, daemon=True).start()
 
@@ -1732,6 +1763,169 @@ def config_mcp(
         return
 
 
+@app.command()
+def export(
+    tool_name: str | None = typer.Argument(None, help="Tool name to export (or use --all)"),
+    format: str = typer.Option("typescript", "--format", "-f", help="Export format"),
+    output: Path | None = typer.Option(None, "--output", "-o", help="Output file"),
+    all: bool = typer.Option(False, "--all", help="Export all tools"),
+    profile: str | None = typer.Option(None, "--profile", help="MCP profile"),
+    mcp_url: str | None = typer.Option(None, "--mcp-url", help="MCP service URL"),
+):
+    """
+    Export MCP tool schemas in various formats.
+
+    Supported formats: typescript, python, protobuf, thrift, graphql, curl, json, yaml
+
+    Examples:
+        # Export as TypeScript
+        testmcpy export get_chart_data --format typescript
+
+        # Export all tools as Python to file
+        testmcpy export --all --format python -o schemas.py
+
+        # Generate cURL command
+        testmcpy export list_datasets --format curl
+
+        # Use specific profile
+        testmcpy export search --format protobuf --profile production
+    """
+    from testmcpy.formatters import FORMATS
+
+    # Load config with profile if specified
+    if profile:
+        from testmcpy.config import Config
+
+        cfg = Config(profile=profile)
+        effective_mcp_url = mcp_url or cfg.mcp_url
+    else:
+        effective_mcp_url = mcp_url or DEFAULT_MCP_URL
+
+    # Validate format
+    if format not in FORMATS:
+        console.print(f"[red]Error: Unknown format '{format}'[/red]")
+        console.print(f"[yellow]Supported formats: {', '.join(FORMATS.keys())}[/yellow]")
+        raise typer.Exit(1)
+
+    # Validate that either tool_name or --all is provided
+    if not tool_name and not all:
+        console.print("[red]Error: Either specify a tool name or use --all flag[/red]")
+        console.print("[yellow]Example: testmcpy export my_tool --format typescript[/yellow]")
+        raise typer.Exit(1)
+
+    async def export_schemas():
+        from testmcpy.src.mcp_client import MCPClient
+
+        console.print(
+            Panel.fit(
+                f"[bold cyan]Export MCP Tool Schemas[/bold cyan]\n"
+                f"Format: {FORMATS[format]['label']} | Service: {effective_mcp_url}",
+                border_style="cyan",
+            )
+        )
+
+        try:
+            with console.status("[bold green]Connecting to MCP service...[/bold green]"):
+                async with MCPClient(effective_mcp_url) as client:
+                    tools = await client.list_tools()
+
+                    if not tools:
+                        console.print("[yellow]No tools found in MCP service[/yellow]")
+                        return
+
+                    # Filter tools if specific tool requested
+                    if not all:
+                        tools = [t for t in tools if t.name == tool_name]
+                        if not tools:
+                            console.print(f"[red]Error: Tool '{tool_name}' not found[/red]")
+                            console.print(
+                                f"[yellow]Available tools: {', '.join([t.name for t in await client.list_tools()])}[/yellow]"
+                            )
+                            return
+
+                    console.print(
+                        f"[green]✓ Found {len(tools)} tool(s) to export[/green]\n"
+                    )
+
+                    # Get the conversion function
+                    convert_func = FORMATS[format]["convert"]
+                    language = FORMATS[format]["language"]
+
+                    # Generate output
+                    output_lines = []
+
+                    for i, tool in enumerate(tools):
+                        # Add separator between tools when exporting all
+                        if all and i > 0:
+                            if format in ["typescript", "python"]:
+                                output_lines.append("\n\n")
+                            elif format in ["protobuf", "thrift", "graphql"]:
+                                output_lines.append("\n")
+                            elif format == "curl":
+                                output_lines.append("\n" + "=" * 80 + "\n\n")
+                            else:
+                                output_lines.append("\n---\n\n")
+
+                        # Add tool name comment for clarity when exporting all
+                        if all:
+                            if format in ["typescript", "python", "protobuf", "thrift", "graphql"]:
+                                output_lines.append(f"// Tool: {tool.name}\n")
+                            elif format == "yaml":
+                                output_lines.append(f"# Tool: {tool.name}\n")
+
+                        # Convert schema
+                        if format == "curl":
+                            converted = convert_func(tool.input_schema, tool.name)
+                        elif format in ["json", "yaml"]:
+                            # For JSON/YAML, include tool metadata
+                            schema_with_metadata = {
+                                "name": tool.name,
+                                "description": tool.description,
+                                "input_schema": tool.input_schema,
+                            }
+                            converted = convert_func(schema_with_metadata)
+                        else:
+                            # For code formats, use a nice name
+                            name = "".join(
+                                word.capitalize() for word in tool.name.replace("-", "_").split("_")
+                            )
+                            if format == "typescript":
+                                name = f"{name}Params"
+                            elif format == "python":
+                                name = f"{name}Params"
+                            elif format == "protobuf":
+                                name = f"{name}Request"
+                            elif format == "thrift":
+                                name = f"{name}Request"
+                            elif format == "graphql":
+                                name = f"{name}Input"
+
+                            converted = convert_func(tool.input_schema, name)
+
+                        output_lines.append(converted)
+
+                    output_text = "".join(output_lines)
+
+                    # Display or save output
+                    if output:
+                        output.write_text(output_text)
+                        console.print(f"[green]✓ Exported to {output}[/green]")
+                    else:
+                        # Display with syntax highlighting
+                        console.print(Syntax(output_text, language, theme="monokai"))
+
+        except Exception as e:
+            console.print(
+                Panel(
+                    f"[red]Error exporting schemas:[/red]\n{str(e)}",
+                    title="[red]Error[/red]",
+                    border_style="red",
+                )
+            )
+
+    asyncio.run(export_schemas())
+
+
 @app.command()
 def doctor():
     """

{testmcpy-0.2.2 → testmcpy-0.2.4}/testmcpy/config.py

@@ -102,7 +102,11 @@ class Config:
                 self._sources[key] = "Default"
 
     def _load_profile(self, profile_id: str | None = None):
-        """Load configuration from MCP profile."""
+        """Load configuration from MCP profile.
+
+        For backward compatibility with single-MCP configs, if a profile has only one MCP,
+        we'll use that MCP's URL and auth as the default MCP_URL and auth settings.
+        """
         try:
             profile = load_profile(profile_id)
             if not profile:
@@ -110,30 +114,37 @@ class Config:
 
             self._profile = profile
 
-            # Set MCP URL
-            self._config["MCP_URL"] = profile.mcp_url
-            self._sources["MCP_URL"] = f"Profile ({profile.profile_id})"
-
-            # Set auth configuration based on auth type
-            if profile.auth.auth_type == "bearer" and profile.auth.token:
-                self._config["MCP_AUTH_TOKEN"] = profile.auth.token
-                self._sources["MCP_AUTH_TOKEN"] = f"Profile ({profile.profile_id})"
-
-            elif profile.auth.auth_type == "jwt":
-                if profile.auth.api_url:
-                    self._config["MCP_AUTH_API_URL"] = profile.auth.api_url
-                    self._sources["MCP_AUTH_API_URL"] = f"Profile ({profile.profile_id})"
-                if profile.auth.api_token:
-                    self._config["MCP_AUTH_API_TOKEN"] = profile.auth.api_token
-                    self._sources["MCP_AUTH_API_TOKEN"] = f"Profile ({profile.profile_id})"
-                if profile.auth.api_secret:
-                    self._config["MCP_AUTH_API_SECRET"] = profile.auth.api_secret
-                    self._sources["MCP_AUTH_API_SECRET"] = f"Profile ({profile.profile_id})"
-
-            # OAuth not yet implemented in auth flow, but store for future use
-            elif profile.auth.auth_type == "oauth":
-                # Store OAuth config for future use
-                pass
+            # For backward compatibility: if profile has exactly one MCP, use it as default
+            if profile.mcps and len(profile.mcps) == 1:
+                first_mcp = profile.mcps[0]
+
+                # Set MCP URL
+                self._config["MCP_URL"] = first_mcp.mcp_url
+                self._sources["MCP_URL"] = f"Profile ({profile.profile_id})"
+
+                # Set auth configuration based on auth type
+                if first_mcp.auth.auth_type == "bearer" and first_mcp.auth.token:
+                    self._config["MCP_AUTH_TOKEN"] = first_mcp.auth.token
+                    self._sources["MCP_AUTH_TOKEN"] = f"Profile ({profile.profile_id})"
+
+                elif first_mcp.auth.auth_type == "jwt":
+                    if first_mcp.auth.api_url:
+                        self._config["MCP_AUTH_API_URL"] = first_mcp.auth.api_url
+                        self._sources["MCP_AUTH_API_URL"] = f"Profile ({profile.profile_id})"
+                    if first_mcp.auth.api_token:
+                        self._config["MCP_AUTH_API_TOKEN"] = first_mcp.auth.api_token
+                        self._sources["MCP_AUTH_API_TOKEN"] = f"Profile ({profile.profile_id})"
+                    if first_mcp.auth.api_secret:
+                        self._config["MCP_AUTH_API_SECRET"] = first_mcp.auth.api_secret
+                        self._sources["MCP_AUTH_API_SECRET"] = f"Profile ({profile.profile_id})"
+
+                # OAuth not yet implemented in auth flow, but store for future use
+                elif first_mcp.auth.auth_type == "oauth":
+                    # Store OAuth config for future use
+                    pass
+
+            # If profile has multiple MCPs, don't set default MCP_URL/auth
+            # The API will handle loading all MCPs from the profile
 
         except Exception as e:
             import warnings

{testmcpy-0.2.2 → testmcpy-0.2.4}/testmcpy/evals/base_evaluators.py

@@ -731,6 +731,127 @@ class ToolCallCount(BaseEvaluator):
             )
 
 
+class ToolCallSequence(BaseEvaluator):
+    """Check that tools were called in a specific order."""
+
+    def __init__(
+        self,
+        sequence: list[str],
+        strict: bool = True,
+        allow_intermediate: bool = False,
+    ):
+        """
+        Check tool call sequence.
+
+        Args:
+            sequence: List of tool names that should be called in order
+            strict: If True, sequence must match exactly (no extra tools).
+                   If False, only checks that sequence appears in order.
+            allow_intermediate: If True, allows other tools between sequence steps.
+                              Only applies when strict=False.
+
+        Examples:
+            # Strict sequence - must be exactly these tools in this order
+            ToolCallSequence(["list_datasets", "generate_chart"], strict=True)
+
+            # Loose sequence - these tools must appear in order, but other tools allowed
+            ToolCallSequence(["list_datasets", "generate_chart"], strict=False, allow_intermediate=True)
+        """
+        self.sequence = sequence
+        self.strict = strict
+        self.allow_intermediate = allow_intermediate
+
+    @property
+    def name(self) -> str:
+        return f"tool_call_sequence:{' -> '.join(self.sequence)}"
+
+    @property
+    def description(self) -> str:
+        if self.strict:
+            return f"Checks that tools are called in exact sequence: {' -> '.join(self.sequence)}"
+        elif self.allow_intermediate:
+            return f"Checks that tools appear in order (other tools allowed): {' -> '.join(self.sequence)}"
+        else:
+            return f"Checks that only these tools are called in order: {' -> '.join(self.sequence)}"
+
+    def evaluate(self, context: dict[str, Any]) -> EvalResult:
+        tool_calls = context.get("tool_calls", [])
+
+        if not tool_calls:
+            return EvalResult(
+                passed=False,
+                score=0.0,
+                reason="No tool calls found in response",
+            )
+
+        actual_sequence = [call.get("name") for call in tool_calls]
+
+        if self.strict:
+            # Exact match required
+            if actual_sequence == self.sequence:
+                return EvalResult(
+                    passed=True,
+                    score=1.0,
+                    reason=f"Tools called in exact sequence: {' -> '.join(actual_sequence)}",
+                    details={"actual_sequence": actual_sequence, "expected_sequence": self.sequence},
+                )
+            else:
+                return EvalResult(
+                    passed=False,
+                    score=0.0,
+                    reason=f"Sequence mismatch. Expected: {' -> '.join(self.sequence)}, Got: {' -> '.join(actual_sequence)}",
+                    details={"actual_sequence": actual_sequence, "expected_sequence": self.sequence},
+                )
+
+        # Non-strict mode: check if sequence appears in order
+        sequence_idx = 0
+        found_positions = []
+
+        for i, tool_name in enumerate(actual_sequence):
+            if sequence_idx < len(self.sequence) and tool_name == self.sequence[sequence_idx]:
+                found_positions.append(i)
+                sequence_idx += 1
+            elif not self.allow_intermediate and tool_name not in self.sequence:
+                # Found a tool not in our sequence and intermediates not allowed
+                return EvalResult(
+                    passed=False,
+                    score=sequence_idx / len(self.sequence),
+                    reason=f"Unexpected tool '{tool_name}' at position {i}. Only {self.sequence} allowed.",
+                    details={
+                        "actual_sequence": actual_sequence,
+                        "expected_sequence": self.sequence,
+                        "found_up_to_index": sequence_idx,
+                        "unexpected_tool": tool_name,
+                    },
+                )
+
+        # Check if we found all tools in the sequence
+        if sequence_idx == len(self.sequence):
+            return EvalResult(
+                passed=True,
+                score=1.0,
+                reason=f"Required tools called in correct order: {' -> '.join([actual_sequence[i] for i in found_positions])}",
+                details={
+                    "actual_sequence": actual_sequence,
+                    "expected_sequence": self.sequence,
+                    "found_positions": found_positions,
+                },
+            )
+        else:
+            missing_tools = self.sequence[sequence_idx:]
+            return EvalResult(
+                passed=False,
+                score=sequence_idx / len(self.sequence),
+                reason=f"Incomplete sequence. Found {sequence_idx}/{len(self.sequence)} tools. Missing: {' -> '.join(missing_tools)}",
+                details={
+                    "actual_sequence": actual_sequence,
+                    "expected_sequence": self.sequence,
+                    "found_up_to_index": sequence_idx,
+                    "missing_tools": missing_tools,
+                },
+            )
+
+
 # Superset-specific evaluators
 
 
@@ -898,6 +1019,7 @@ def create_evaluator(name: str, **kwargs) -> BaseEvaluator:
         "tool_called_with_parameters": ToolCalledWithParameters,
         "parameter_value_in_range": ParameterValueInRange,
         "tool_call_count": ToolCallCount,
+        "tool_call_sequence": ToolCallSequence,
         # Superset-specific evaluators
         "was_superset_chart_created": WasSupersetChartCreated,
         "sql_query_valid": SQLQueryValid,

testmcpy-0.2.4/testmcpy/formatters/__init__.py

@@ -0,0 +1,46 @@
+"""
+Schema formatters for converting JSON Schema to various formats.
+
+This module provides formatters for converting MCP tool schemas to
+TypeScript, Python, Protobuf, Thrift, GraphQL, cURL, JSON, and YAML.
+"""
+
+from .curl import to_curl
+from .graphql import to_graphql
+from .javascript_client import to_javascript_client
+from .json_yaml import to_json, to_yaml
+from .protobuf import to_protobuf
+from .python import to_python
+from .python_client import to_python_client
+from .thrift import to_thrift
+from .typescript import to_typescript
+from .typescript_client import to_typescript_client
+
+__all__ = [
+    "to_typescript",
+    "to_python",
+    "to_protobuf",
+    "to_thrift",
+    "to_graphql",
+    "to_curl",
+    "to_json",
+    "to_yaml",
+    "to_python_client",
+    "to_javascript_client",
+    "to_typescript_client",
+]
+
+# Format registry for easy lookup
+FORMATS = {
+    "json": {"label": "JSON", "language": "json", "convert": to_json},
+    "yaml": {"label": "YAML", "language": "yaml", "convert": to_yaml},
+    "typescript": {"label": "TypeScript", "language": "typescript", "convert": to_typescript},
+    "python": {"label": "Python", "language": "python", "convert": to_python},
+    "protobuf": {"label": "Protobuf", "language": "protobuf", "convert": to_protobuf},
+    "thrift": {"label": "Thrift", "language": "thrift", "convert": to_thrift},
+    "graphql": {"label": "GraphQL", "language": "graphql", "convert": to_graphql},
+    "curl": {"label": "cURL", "language": "bash", "convert": to_curl},
+    "python_client": {"label": "Python Client", "language": "python", "convert": to_python_client},
+    "javascript_client": {"label": "JavaScript Client", "language": "javascript", "convert": to_javascript_client},
+    "typescript_client": {"label": "TypeScript Client", "language": "typescript", "convert": to_typescript_client},
+}