dtlpymcp 0.1.4__py3-none-any.whl → 0.1.8__py3-none-any.whl

dtlpymcp/__init__.py

@@ -1,7 +1,4 @@
-import os
-SOURCES_FILEPATH = os.path.join(os.path.dirname(__file__), "default_sources.json")
-
 from .utils.dtlpy_context import DataloopContext, MCPSource
 
-__version__ = "0.1.4"
+__version__ = "0.1.8"
 

dtlpymcp/__main__.py

@@ -21,11 +21,26 @@ def main():
         default=None,
         help="Path to a JSON file with MCP sources to load"
     )
+    start_parser.add_argument(
+        "--init-timeout",
+        "-t",
+        type=float,
+        default=30.0,
+        help="Timeout in seconds for Dataloop context initialization (default: 30.0)"
+    )
+    start_parser.add_argument(
+        "--log-level",
+        "-l",
+        type=str,
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        default="DEBUG",
+        help="Logging verbosity level (default: DEBUG)"
+    )
 
     args = parser.parse_args()
 
     if args.command == "start":
-        sys.exit(proxy_main(sources_file=args.sources_file))
+        sys.exit(proxy_main(sources_file=args.sources_file, init_timeout=args.init_timeout, log_level=args.log_level))
     else:
         parser.print_help()
         return 1

dtlpymcp/proxy.py

@@ -1,101 +1,74 @@
-from pydantic_settings import BaseSettings, SettingsConfigDict
-from mcp.server.fastmcp import FastMCP, Context
-from typing import Any, Optional
-from datetime import datetime
-import traceback
-import logging
-import asyncio
-import os
-from pathlib import Path
-
-from dtlpymcp.utils.dtlpy_context import DataloopContext, SOURCES_FILEPATH
-
-# Setup logging to both console and file with timestamp
-log_dir = Path.home() / ".dataloop" / "mcplogs"
-log_dir.mkdir(parents=True, exist_ok=True)
-log_file = log_dir / f"{datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}.log"
-
-# Remove any existing handlers
-for handler in logging.root.handlers[:]:
-    logging.root.removeHandler(handler)
-
-# File handler with timestamp
-file_handler = logging.FileHandler(log_file, mode="a", encoding="utf-8")
-file_handler.setFormatter(
-    logging.Formatter(fmt="%(asctime)s [%(levelname)s] %(name)s: %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
-)
-
-# Console handler (default format)
-console_handler = logging.StreamHandler()
-console_handler.setFormatter(logging.Formatter(fmt="[%(levelname)s] %(name)s: %(message)s"))
-
-logging.basicConfig(level=logging.INFO, handlers=[file_handler, console_handler])
-logger = logging.getLogger("[DATALOOP-MCP]")
-
-
-class ServerSettings(BaseSettings):
-    """Settings for the Dataloop MCP server."""
-
-    model_config = SettingsConfigDict(env_prefix="MCP_DATALOOP_")
-
-    def __init__(self, **data):
-        super().__init__(**data)
-
-
-def create_dataloop_mcp_server(settings: ServerSettings, sources_file: str) -> FastMCP:
-    """Create a FastMCP server for Dataloop with Bearer token authentication."""
-    app = FastMCP(
-        name="Dataloop MCP Server",
-        instructions="A multi-tenant MCP server for Dataloop with authentication",
-        stateless_http=True,
-        debug=True,
-    )
-    dl_context = DataloopContext(token=os.environ.get('DATALOOP_API_KEY'), 
-                                 env=os.environ.get('DATALOOP_ENV', 'prod'),
-                                 sources_file=sources_file)
-    
-    # Initialize the Dataloop context
-    asyncio.run(dl_context.initialize())
-    
-    @app.tool(description="Test tool for health checks")
-    async def test(ctx: Context, ping: Any = None) -> dict[str, Any]:
-        """Health check tool. Returns status ok and echoes ping if provided."""
-        result = {"status": "ok"}
-        if ping is not None:
-            result["ping"] = ping
-        return result
-
-    logger.info(f"Adding tools from {len(dl_context.mcp_sources)} sources")
-
-    for source in dl_context.mcp_sources:
-        logger.info(f"Adding tools from source: {source.dpk_name}")
-        for tool in source.tools:
-            app._tool_manager._tools[tool.name] = tool
-            logger.info(f"Registered tool: {tool.name}")
-    
-    return app
-
-
-def main(sources_file: Optional[str] = None) -> int:
-    logger.info("Starting Dataloop MCP server in stdio mode")
-    try:
-        settings = ServerSettings()
-        logger.info("Successfully configured Dataloop MCP server")
-    except Exception as e:
-        logger.error(f"Unexpected error during startup:\n{e}")
-        return 1
-    try:
-        if sources_file is None:
-            sources_file = SOURCES_FILEPATH
-        logger.info(f"Using sources file: {sources_file}")
-        mcp_server = create_dataloop_mcp_server(settings, sources_file)
-        logger.info("Starting Dataloop MCP server in stdio mode")
-        mcp_server.run(transport="stdio")
-        return 0
-    except Exception:
-        logger.error(f"Failed to start MCP server: {traceback.format_exc()}")
-        return 1
-
-
-if __name__ == "__main__":
-    main()
+
+from mcp.server.fastmcp import FastMCP, Context
+from typing import Any, Optional
+import traceback
+import os
+
+from dtlpymcp.utils.dtlpy_context import DataloopContext
+from dtlpymcp.utils.server_utils import safe_initialize_dataloop_context
+from dtlpymcp.utils.logging_config import setup_logging, get_logger
+
+# Get the main logger
+logger = get_logger()
+
+
+def create_dataloop_mcp_server(sources_file: Optional[str] = None, init_timeout: float = 30.0) -> FastMCP:
+    """Create a FastMCP server for Dataloop with Bearer token authentication."""
+    app = FastMCP(
+        name="Dataloop MCP Server",
+        instructions="A multi-tenant MCP server for Dataloop with authentication",
+        stateless_http=True,
+        debug=True,
+    )
+    
+    # Create Dataloop context
+    dl_context = DataloopContext(token=os.environ.get('DATALOOP_API_KEY'), 
+                                 env=os.environ.get('DATALOOP_ENV', 'prod'),
+                                 sources_file=sources_file)
+    
+    @app.tool(description="Test tool for health checks")
+    async def test(ctx: Context, ping: Any = None) -> dict[str, Any]:
+        """Health check tool. Returns status ok and echoes ping if provided."""
+        result = {"status": "ok"}
+        if ping is not None:
+            result["ping"] = ping
+        return result
+
+    # Initialize context using the safe utility function
+    initialization_success = safe_initialize_dataloop_context(dl_context, app, init_timeout)
+    
+    if not initialization_success:
+        logger.info("Server will start without Dataloop tools - they will be available on next restart")
+        # Continue without initialization - the server will still work with the test tool
+    
+    return app
+
+
+def main(sources_file: Optional[str] = None, init_timeout: float = 30.0, log_level: str = "DEBUG") -> int:
+    # Setup logging with the specified level
+    setup_logging(log_level)
+    
+    logger.info("Starting Dataloop MCP server in stdio mode")
+    
+    # Validate environment variables
+    if not os.environ.get('DATALOOP_API_KEY'):
+        logger.error("DATALOOP_API_KEY environment variable is required")
+        return 1
+    
+    try:
+        mcp_server = create_dataloop_mcp_server(sources_file=sources_file, init_timeout=init_timeout)
+        logger.info("Dataloop MCP server created successfully")
+        logger.info("Starting server in stdio mode...")
+        mcp_server.run(transport="stdio")
+        return 0
+    except KeyboardInterrupt:
+        logger.info("Server stopped by user")
+        return 0
+    except Exception as e:
+        logger.error(f"Failed to start MCP server: {e}")
+        logger.error(f"Traceback: {traceback.format_exc()}")
+        return 1
+
+
+if __name__ == "__main__":
+    main()

dtlpymcp/utils/dtlpy_context.py

@@ -1,8 +1,7 @@
 from mcp.server.fastmcp.utilities.func_metadata import ArgModelBase, FuncMetadata
 from mcp.client.streamable_http import streamablehttp_client
-from typing import Any, List, Tuple, Callable, Optional
+from typing import List, Tuple, Callable, Optional
 from mcp.server.fastmcp.tools.base import Tool
-from mcp.server.fastmcp import FastMCP
 from pydantic import BaseModel, Field
 from pydantic import create_model
 from datetime import timedelta
@@ -10,28 +9,13 @@ from mcp import ClientSession
 import dtlpy as dl
 import traceback
 import requests
-import logging
-import asyncio
 import time
 import jwt
 import json
-from dtlpymcp import SOURCES_FILEPATH
 
-# Utility to run async code from sync or async context
-# If called from a running event loop, returns a Task (caller must handle it)
-# If called from sync, blocks and returns result
+from dtlpymcp.utils.logging_config import get_logger
 
-def run_async(coro):
-    try:
-        loop = asyncio.get_running_loop()
-    except RuntimeError:
-        # No event loop running
-        return asyncio.run(coro)
-    else:
-        # Already running event loop
-        return loop.create_task(coro)
-
-logger = logging.getLogger(__name__)
+logger = get_logger("dtlpy_context")
 
 
 class MCPSource(BaseModel):
@@ -53,31 +37,55 @@ class DataloopContext:
         self.env = env
         self.mcp_sources: List[MCPSource] = []
         logger.info("DataloopContext initialized.")
-        if sources_file is None:
-            sources_file = SOURCES_FILEPATH
         self.sources_file = sources_file
         self.initialized = False
-        
-    
+
     async def initialize(self, force: bool = False):
-        if not self.initialized or force:    
+        if not self.initialized or force:
             await self.register_sources(self.sources_file)
             self.initialized = True
 
-    async def register_sources(self, sources_file: str):
-        with open(sources_file, "r") as f:
-            data = json.load(f)
-        logger.info(f"Loading MCP sources from {sources_file}")
-        for entry in data:
-            if not isinstance(entry, dict):
-                raise ValueError(f"Invalid source entry: {entry}")
-            logger.info(f"Adding MCP source: {entry.get('dpk_name')}, url: {entry.get('server_url')}")
-            await self.add_mcp_source(MCPSource(**entry))
+    async def register_sources(self, sources_file: str = None):
+        if sources_file is None:
+            logger.info("Loading MCP sources from all system apps")
+            # load all system apps
+            filters = dl.Filters(resource='apps')
+            filters.add(field="dpkName", values="dataloop-mcp*")
+            filters.add(field="scope", values="system")
+            apps = list(dl.apps.list(filters=filters).all())
+            if len(apps) == 0:
+                raise ValueError(f"No app found for DPK name: dataloop-mcp*")
+            sources = []
+            for app in apps:
+                sources.append(
+                    {
+                        "dpk_name": app.dpk_name,
+                        "app_url": next(iter(app.routes.values())),
+                        "server_url": None,
+                        "app_jwt": None,
+                    }
+                )
+        else:
+            logger.info(f"Loading MCP sources from {sources_file}")
+
+            with open(sources_file, "r") as f:
+                sources = json.load(f)
+        for entry in sources:
+            try:
+                if not isinstance(entry, dict):
+                    raise ValueError(f"Invalid source entry: {entry}")
+                logger.info(f"Adding MCP source: {entry.get('dpk_name')}, url: {entry.get('server_url')}")
+                await self.add_mcp_source(MCPSource(**entry))
+            except Exception as e:
+                logger.error(f"Failed to add MCP source: {entry}\n{traceback.format_exc()}")
 
     async def add_mcp_source(self, mcp_source: MCPSource):
-        self.mcp_sources.append(mcp_source)
+
         if mcp_source.server_url is None:
-            self.load_app_info(mcp_source)
+            success = self.load_app_info(mcp_source)
+            if not success:
+                logger.error(f"Failed to load app info for source {mcp_source.dpk_name}")
+                return
         result = await self.list_source_tools(mcp_source)
         if result is None:
             raise ValueError(f"Failed to discover tools for source {mcp_source.dpk_name}")
@@ -111,6 +119,7 @@ class DataloopContext:
                 annotations=None,
             )
             mcp_source.tools.append(t)
+        self.mcp_sources.append(mcp_source)
         tool_str = ", ".join([tool.name for tool in mcp_source.tools])
         logger.info(f"Added MCP source: {mcp_source.dpk_name}, Available tools: {tool_str}")
 
@@ -122,18 +131,25 @@ class DataloopContext:
     def token(self, token: str):
         self._token = token
 
-    def load_app_info(self, source: MCPSource) -> None:
+    def load_app_info(self, source: MCPSource) -> bool:
         """
         Get the source URL and app JWT for a given DPK name using Dataloop SDK.
         """
         try:
-            dl.setenv(self.env)
-            dl.client_api.token = self.token
-            dpk = dl.dpks.get(dpk_name=source.dpk_name)
-            apps_filters = dl.Filters(field='dpkName', values=dpk.name, resource='apps')
-            app = dl.apps.list(filters=apps_filters).items[0]
-            logger.info(f"App: {app.name}")
-            source.app_url = next(iter(app.routes.values()))
+            if source.app_url is None:
+                dl.setenv(self.env)
+                dl.client_api.token = self.token
+                filters = dl.Filters(resource='apps')
+                filters.add(field="dpkName", values=source.dpk_name)
+                filters.add(field="scope", values="system")
+                apps = list(dl.apps.list(filters=filters).all())
+                if len(apps) == 0:
+                    raise ValueError(f"No app found for DPK name: {source.dpk_name}")
+                if len(apps) > 1:
+                    logger.warning(f"Multiple apps found for DPK name: {source.dpk_name}, using first one")
+                app = apps[0]
+                logger.info(f"App: {app.name}")
+                source.app_url = next(iter(app.routes.values()))
             session = requests.Session()
             response = session.get(source.app_url, headers=dl.client_api.auth)
             logger.info(f"App route URL: {response.url}")
@@ -141,7 +157,8 @@ class DataloopContext:
             source.app_jwt = session.cookies.get("JWT-APP")
         except Exception:
             logger.error(f"Failed getting app info: {traceback.format_exc()}")
-            raise ValueError(f"Failed getting app info: {traceback.format_exc()}")
+            return False
+        return True
 
     @staticmethod
     def is_expired(app_jwt: str) -> bool:
@@ -163,18 +180,16 @@ class DataloopContext:
         """
         Get the APP_JWT from the request headers or refresh if expired.
         """
+        if source.app_url is None:
+            raise ValueError("App URL is missing. Please set the app URL.")
         if source.app_jwt is None or self.is_expired(source.app_jwt):
             try:
                 session = requests.Session()
                 response = session.get(source.app_url, headers={'authorization': 'Bearer ' + token})
                 source.app_jwt = session.cookies.get("JWT-APP")
             except Exception:
-                logger.error(f"Failed getting app JWT from cookies\n{traceback.format_exc()}")
                 raise Exception(f"Failed getting app JWT from cookies\n{traceback.format_exc()}") from None
         if not source.app_jwt:
-            logger.error(
-                "APP_JWT is missing. Please set the APP_JWT environment variable or ensure authentication is working."
-            )
             raise ValueError(
                 "APP_JWT is missing. Please set the APP_JWT environment variable or ensure authentication is working."
             )
@@ -195,8 +210,7 @@ class DataloopContext:
         if source.server_url is None:
             logger.error("DataloopContext required for DPK servers")
             raise ValueError("DataloopContext required for DPK servers")
-        headers = {"Cookie": f"JWT-APP={source.app_jwt}",
-                   "x-dl-info": f"{self.token}"}
+        headers = {"Cookie": f"JWT-APP={source.app_jwt}", "x-dl-info": f"{self.token}"}
         async with streamablehttp_client(source.server_url, headers=headers) as (read, write, _):
             async with ClientSession(read, write, read_timeout_seconds=timedelta(seconds=60)) as session:
                 await session.initialize()

dtlpymcp/utils/logging_config.py

@@ -0,0 +1,61 @@
+"""
+Centralized logging configuration for dtlpymcp.
+Handles file and console logging with configurable verbosity levels.
+"""
+
+import logging
+from datetime import datetime
+from pathlib import Path
+
+
+def setup_logging(log_level: str = "DEBUG") -> None:
+    """
+    Set up logging configuration for the entire dtlpymcp application.
+    
+    Args:
+        log_level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+    """
+    # Convert string level to logging constant
+    level = getattr(logging, log_level.upper(), logging.DEBUG)
+    
+    # Setup logging directory and file
+    log_dir = Path.home() / ".dataloop" / "mcplogs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_file = log_dir / f"{datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}.log"
+    
+    # Remove any existing handlers
+    for handler in logging.root.handlers[:]:
+        logging.root.removeHandler(handler)
+    
+    # File handler with timestamp
+    file_handler = logging.FileHandler(log_file, mode="a", encoding="utf-8")
+    file_handler.setFormatter(
+        logging.Formatter(fmt="%(asctime)s [%(levelname)s] %(name)s: %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
+    )
+    
+    # Console handler (default format)
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(logging.Formatter(fmt="[%(levelname)s] %(name)s: %(message)s"))
+    
+    # Configure root logger
+    logging.basicConfig(level=level, handlers=[file_handler, console_handler])
+    
+    # Get the main logger
+    logger = logging.getLogger("dtlpymcp")
+    logger.info(f"Logging configured with level: {log_level.upper()}")
+    logger.info(f"Log file: {log_file}")
+
+
+def get_logger(name: str = None) -> logging.Logger:
+    """
+    Get a logger instance with the specified name.
+    
+    Args:
+        name: Logger name (optional, defaults to "dtlpymcp")
+        
+    Returns:
+        logging.Logger: Configured logger instance
+    """
+    if name is None:
+        return logging.getLogger("dtlpymcp")
+    return logging.getLogger(f"dtlpymcp.{name}")

dtlpymcp/utils/server_utils.py

@@ -0,0 +1,91 @@
+"""
+Utility functions for Dataloop MCP server initialization and management.
+"""
+
+import asyncio
+from mcp.server.fastmcp import FastMCP
+from dtlpymcp.utils.dtlpy_context import DataloopContext
+from dtlpymcp.utils.logging_config import get_logger
+
+logger = get_logger("server_utils")
+
+
+def run_async(coro):
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        # No event loop running
+        return asyncio.run(coro)
+    else:
+        # Already running event loop
+        return loop.create_task(coro)
+
+
+async def initialize_dataloop_context(dl_context: DataloopContext, app: FastMCP, init_timeout: float = 30.0) -> bool:
+    """
+    Initialize Dataloop context with timeout protection.
+
+    Args:
+        dl_context: The DataloopContext instance to initialize
+        app: The FastMCP app instance to register tools with
+        init_timeout: Timeout in seconds for initialization
+
+    Returns:
+        bool: True if initialization succeeded, False otherwise
+    """
+    try:
+        logger.info("Initializing Dataloop context...")
+        # Use asyncio.wait_for for timeout protection
+        await asyncio.wait_for(dl_context.initialize(), timeout=init_timeout)
+        logger.info("Dataloop context initialized successfully")
+
+        # Register tools after initialization
+        logger.info(f"Adding tools from {len(dl_context.mcp_sources)} sources")
+        for source in dl_context.mcp_sources:
+            logger.info(f"Adding tools from source: {source.dpk_name}")
+            for tool in source.tools:
+                app._tool_manager._tools[tool.name] = tool
+                logger.info(f"Registered tool: {tool.name}")
+
+        return True
+
+    except asyncio.TimeoutError:
+        logger.error("Timeout during Dataloop context initialization")
+        return False
+    except Exception as e:
+        logger.error(f"Failed to initialize Dataloop context: {e}")
+        return False
+
+
+def safe_initialize_dataloop_context(dl_context: DataloopContext, app: FastMCP, init_timeout: float = 30.0) -> bool:
+    """
+    Safely initialize Dataloop context using run_async utility.
+
+    Args:
+        dl_context: The DataloopContext instance to initialize
+        app: The FastMCP app instance to register tools with
+        init_timeout: Timeout in seconds for initialization
+
+    Returns:
+        bool: True if initialization succeeded, False otherwise
+    """
+    try:
+        # Use the run_async utility to handle async execution properly
+        result = run_async(initialize_dataloop_context(dl_context, app, init_timeout))
+
+        # Handle different return types from run_async
+        if hasattr(result, 'done'):
+            # It's a task, wait for it to complete
+            while not result.done():
+                pass
+            return result.result()
+        elif asyncio.iscoroutine(result):
+            # It's a coroutine, run it
+            return asyncio.run(result)
+        else:
+            # It's already the result (bool)
+            return result
+
+    except Exception as e:
+        logger.error(f"Failed to initialize during server creation: {e}")
+        return False

{dtlpymcp-0.1.4.dist-info → dtlpymcp-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dtlpymcp
-Version: 0.1.4
+Version: 0.1.8
 Summary: STDIO MCP proxy server for Dataloop platform.
 Author-email: Your Name <your.email@example.com>
 Classifier: Programming Language :: Python :: 3.10
@@ -30,7 +30,14 @@ pip install git+<repository-url>
 You can run the proxy server via CLI:
 
 ```shell
+# Basic usage
 dtlpymcp start
+
+# With custom sources file
+dtlpymcp start --sources-file /path/to/sources.json
+
+# With custom initialization timeout (default: 30 seconds)
+dtlpymcp start --init-timeout 60.0
 ```
 
 Or using Python module syntax:
@@ -45,6 +52,14 @@ python -m dtlpymcp start
 - Install dependencies with `pip install -e .`
 - Run tests with `pytest`
 
+## Architecture
+
+The server uses a modular architecture with utilities for safe async initialization:
+
+- `dtlpymcp/proxy.py` - Main server implementation using FastMCP
+- `dtlpymcp/utils/server_utils.py` - Safe async initialization utilities
+- `dtlpymcp/utils/dtlpy_context.py` - Dataloop context management
+
 ## Cursor MCP Integration
 
 To add this MCP to Cursor, add the following to your configuration:

dtlpymcp-0.1.8.dist-info/RECORD

@@ -0,0 +1,11 @@
+dtlpymcp/__init__.py,sha256=6ARRnx35x-dKohwr72GdxSPqO6JfXU5rDFhM1h-GYDY,88
+dtlpymcp/__main__.py,sha256=BRLHkOrX5Ayea3mMHo7pkY8URnVHzIJfKgWnWr6SdXo,1402
+dtlpymcp/proxy.py,sha256=yL1pa-yDG6snwxsT7PzMIzjRbeV2bEgayJhXLRYzbK0,2815
+dtlpymcp/utils/dtlpy_context.py,sha256=Y4o40ekeZmp63pJ1LwHy5hholkTmpbcg3LoQXd05xac,10553
+dtlpymcp/utils/logging_config.py,sha256=R9eUByUdr3n7Tv9YrCQxH-LyspEjaa5kzR1p8F13q08,2082
+dtlpymcp/utils/server_utils.py,sha256=M-OxGqFqAiGC3xAcNw0Ifkyno7pLInRHA_9LJJI7eQs,3220
+dtlpymcp-0.1.8.dist-info/METADATA,sha256=W10TSsIYzXmapg9dkPk-2dB3mP--_admyvewYU1DdHw,2189
+dtlpymcp-0.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dtlpymcp-0.1.8.dist-info/entry_points.txt,sha256=6hRVZNTjQevj7erwt9dAOURtPVrSrYu6uHXhAlhTaXQ,52
+dtlpymcp-0.1.8.dist-info/top_level.txt,sha256=z85v20pIEnY3cBaWgwhU3EZS4WAZRywejhIutwd-iHk,9
+dtlpymcp-0.1.8.dist-info/RECORD,,

dtlpymcp/default_sources.json

@@ -1,20 +0,0 @@
-[
-    {
-        "dpk_name": "dataloop-mcp-donna",
-        "app_url": null,
-        "server_url": null,
-        "app_jwt": null
-    },
-    {
-        "dpk_name": "dataloop-mcp-apis",
-        "app_url": null,
-        "server_url": null,
-        "app_jwt": null
-    },
-    {
-        "dpk_name": "dataloop-mcp-debug",
-        "app_url": null,
-        "server_url": null,
-        "app_jwt": null
-    }
-]

dtlpymcp-0.1.4.dist-info/RECORD

@@ -1,10 +0,0 @@
-dtlpymcp/__init__.py,sha256=jz6jKLs8djD6u5xy04_NQO7hgKyFea_oPa-yaiQQq0M,185
-dtlpymcp/__main__.py,sha256=1lo4qoZAoUHl9rkt1YGB2kCpKg5cIrTSBSrznxyk6F4,884
-dtlpymcp/default_sources.json,sha256=Es3XZcdMpe6o5FyOoqW9FG_oUjC5gkNbBC6N9eBqpQs,418
-dtlpymcp/proxy.py,sha256=pE-NAJI0A9wKcBJJt18_aSy1BskZKoxaK3f6VW7u44A,3608
-dtlpymcp/utils/dtlpy_context.py,sha256=0NW5FKFpzUl6gTuJGPPPMqklnNuecgBdwLdW-68YUXE,9752
-dtlpymcp-0.1.4.dist-info/METADATA,sha256=_CYzt19o00e_UIw9SeiQXW7lKp5q1Bq2xSSbyF7W3Yc,1677
-dtlpymcp-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dtlpymcp-0.1.4.dist-info/entry_points.txt,sha256=6hRVZNTjQevj7erwt9dAOURtPVrSrYu6uHXhAlhTaXQ,52
-dtlpymcp-0.1.4.dist-info/top_level.txt,sha256=z85v20pIEnY3cBaWgwhU3EZS4WAZRywejhIutwd-iHk,9
-dtlpymcp-0.1.4.dist-info/RECORD,,