mt5api 1.0.0__tar.gz → 1.0.1__tar.gz

{mt5api-1.0.0 → mt5api-1.0.1}/.agents/skills/pr-feedback-triage/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: pr-feedback-triage
 description: Triage pull request review comments into fixes, replies, clarification requests, or open follow-ups while respecting safe execution modes.
+allowed-tools: Bash(git:*), Bash(gh:*), mcp__github__*, Read, Grep, Glob, Edit, MultiEdit, Write
 ---
 
 # PR Feedback Triage
@@ -43,9 +44,10 @@ When a mode disables an action, skip that destructive or externally visible acti
 
 Gather the complete feedback set before editing:
 
-- Fetch unresolved review threads, requested-change reviews, PR-level summary comments, and copied comments.
-- Use platform-native APIs/CLI when available. Paginate results; do not inspect only the first page of threads or comments.
-- For bot reviewers that post both summary comments and inline comments, collect both. Summary comments often contain severity, rationale, and fix instructions; inline comments contain the exact file and line context.
+- Fetch unresolved review threads, requested-change reviews, inline comments, copied comments, and PR-level summary comments.
+- Use whichever authenticated GitHub-capable interface is available and reliable. This skill explicitly permits both `gh` and GitHub MCP tools; paginate results and do not inspect only the first page of threads or comments.
+- For bot reviewers that post both summary comments and inline comments, prefer inline comments for actionable triage. Incorporate summary findings only when they contain distinct severity, rationale, or fix instructions not already captured from inline comments.
+- Summary comments may be excluded from triage when they do not add distinct actionable context.
 - Preserve every thread/comment identifier needed to reply or resolve later.
 - Compare each comment with the current diff and file contents because review lines can become outdated.
 
@@ -56,7 +58,7 @@ Build one triage record per distinct finding:
 - Prefer exact review-thread identity when available.
 - For duplicate bot findings appearing in both summary and inline comments, merge by exact issue title first, then by file path plus line range as a fallback.
 - Prefer inline comments for location and current code context.
-- Prefer summary comments for severity, category, rationale, and detailed agent prompts.
+- Use summary comments only for distinct severity, category, rationale, or detailed agent prompts that are not already available from inline comments.
 - Preserve the reviewer’s exact issue title and original wording where practical. Do not rename findings in a way that would make replies hard to map back to comments.
 - Preserve the reviewer’s original ordering unless the user asks for priority reordering. Many review bots already order findings by severity.
 
@@ -70,13 +72,20 @@ Keep a thread open only when it still needs reviewer, maintainer, or product inp
 
 When resolving a thread, add a concise reply first only if it provides useful context, such as what changed, why no code change was needed, why a finding was intentionally deferred, or why the original comment is now outdated. Do not add noisy replies for self-evident fixes unless project norms require them.
 
+## Platform Comment Style
+
+- Keep every posted reply or comment brief: one sentence by default, two short sentences only when necessary.
+- Do not post PR-level summary or status comments by default. Omit them when they only restate completed fixes, resolved threads, or verification already visible in commits/checks.
+- Avoid templates, long bullet lists, exhaustive status logs, and duplicated explanations in platform comments.
+- For simple fixes, already-addressed findings, or outdated findings, prefer `resolve_only` over adding a reply.
+
 ## Platform Action Contract
 
-Do not treat triage as complete until every collected source ID reaches an explicit terminal state:
+Do not treat triage as complete until every incorporated source ID reaches an explicit terminal state:
 
 - `resolved`: a platform resolve action succeeded, or a re-check shows the thread is already resolved.
 - `replied_left_open`: a reply or question was posted and the thread is intentionally left unresolved.
-- `not_resolvable`: the source is a PR-level summary comment or copied comment that has no platform-level resolve action; reply or post a PR summary when useful.
+- `not_resolvable`: the source is a PR-level summary comment or copied comment that has no platform-level resolve action; post a brief reply only when useful.
 - `skipped_by_mode`: `dry_run`, `no_push`, or `no_reply` prevented the external action.
 - `failed_action`: a reply or resolve action was attempted and failed; include the attempted action and failure in the final summary.
 
@@ -85,13 +94,13 @@ In normal mode, build and execute a platform action queue after fixes are verifi
 - `reply_then_resolve`: use for handled threads where the reviewer needs context before resolution.
 - `resolve_only`: use for self-evident fixes and already-addressed or outdated threads where an extra reply would add noise.
 - `reply_leave_open`: use only for clarification requests, blocked work, or intentionally open follow-ups.
-- `reply_only`: use for PR-level comments or summaries that cannot be resolved as review threads.
+- `reply_only`: use for PR-level comments or summaries that cannot be resolved, only when a short reply adds value.
 
 For duplicate findings, execute the terminal action for every source thread ID, not only the primary triage record. If one finding is represented by three unresolved inline threads, all three must be resolved or explicitly left open.
 
 ## GitHub Action Guidance
 
-Prefer platform-native APIs or `gh` commands that expose review-thread resolution state. For GitHub inline review threads, use the thread node ID and the GraphQL `resolveReviewThread` mutation rather than assuming that a reply resolves the conversation.
+Use whichever authenticated GitHub-capable interface is available and reliable, preferably `gh` or GitHub MCP. Prefer interfaces that expose review-thread resolution state. For GitHub inline review threads, use the thread node ID and the GraphQL `resolveReviewThread` mutation, or an equivalent GitHub MCP resolve-thread tool, rather than assuming that a reply resolves the conversation.
 
 A reliable pattern is:
 
@@ -150,9 +159,9 @@ flowchart TD
 ## Compact Workflow
 
 1. **Collect all relevant feedback**
-   - Identify the PR and gather unresolved review threads, requested-change reviews, PR-level summaries, inline comments, and copied comments.
+   - Identify the PR and gather unresolved review threads, requested-change reviews, inline comments, copied comments, and PR-level summaries.
    - Paginate all platform calls and keep comment/thread IDs for later replies and resolution.
-   - For bot reviews, collect both summary and inline comments, then merge duplicates rather than fixing the same finding twice.
+   - For bot reviews, prioritize inline comments and incorporate summary findings only when they add distinct actionable context.
 
 2. **Classify each triage record**
    - **Fix**: Valid requested change; make the smallest focused edit when not in `dry_run`.
@@ -168,7 +177,7 @@ flowchart TD
    - In `dry_run`, stop at triage, proposed fixes, suggested replies, and verification plan.
    - In `no_push`, local edits are allowed, but do not push or resolve threads whose fix is only local. Reply or resolve non-code, already-addressed, or outdated threads only when the action does not depend on unpushed work and `no_reply` is not set.
    - In `no_reply`, do not post replies or resolve threads; report suggested replies/actions instead.
-   - In normal mode, commit and push changed code when appropriate, then execute the platform action queue for every collected source ID.
+   - In normal mode, commit and push changed code when appropriate, then execute the platform action queue for every incorporated source ID.
 
 4. **Verify before claiming completion**
    - For fixes, run appropriate checks or explain why they could not run.
@@ -178,15 +187,16 @@ flowchart TD
    - If a resolve or reply operation fails, retry once when safe; then report `failed_action` with the affected source ID and reason.
 
 5. **Finish**
-   - Normal mode: commit/push changes when appropriate, post useful replies or a summary, resolve all handled threads by default, and reconcile the final unresolved set.
+   - Normal mode: commit/push changes when appropriate, post only useful short replies/comments, omit PR-level summaries when they add no value, resolve all handled threads by default, and reconcile the final unresolved set.
    - Safe modes: report the local state and the exact replies/resolution actions a human could take.
 
 ## Reply Guidance
 
-- Keep inline replies short and tied to the original title or concern.
-- For fixed findings, mention the concrete change or commit if useful.
-- For already-addressed or outdated findings, cite the current code path or behavior that makes the finding no longer applicable.
+- Keep inline replies short: one sentence by default, two short sentences only when needed.
+- For fixed findings, mention the concrete change or commit only if it helps the reviewer.
+- For already-addressed or outdated findings, cite the current code path or behavior only as briefly as needed.
 - For deferred or won't-fix findings, provide the reason and any follow-up issue or owner if known.
+- Avoid posting PR-level summary comments unless they communicate a decision, blocker, or requested reviewer action.
 - If a reply or resolve operation fails, continue with the remaining threads and report the failure in the final summary.
 
 ## Final Summary Checklist

{mt5api-1.0.0 → mt5api-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mt5api
-Version: 1.0.0
+Version: 1.0.1
 Summary: MetaTrader 5 REST API
 Project-URL: Repository, https://github.com/dceoy/mt5api.git
 Author-email: dceoy <dceoy@users.noreply.github.com>
@@ -18,7 +18,7 @@ Classifier: Topic :: Office/Business :: Financial :: Investment
 Requires-Python: <3.14,>=3.11
 Requires-Dist: fastapi>=0.115.0
 Requires-Dist: httpx>=0.27.0
-Requires-Dist: pdmt5>=1.0.1
+Requires-Dist: pdmt5>=1.1.1
 Requires-Dist: pyarrow>=18.0.0
 Requires-Dist: python-multipart>=0.0.31
 Requires-Dist: uvicorn[standard]>=0.32.0
@@ -30,11 +30,18 @@ MetaTrader 5 REST API
 
 [![CI/CD](https://github.com/dceoy/mt5api/actions/workflows/ci.yml/badge.svg)](https://github.com/dceoy/mt5api/actions/workflows/ci.yml)
 
-mt5api exposes MT5 market data, account info, trading history, and trading
-operations over HTTP. It is a FastAPI/HTTP adapter over
-[`pdmt5`](https://github.com/dceoy/pdmt5), which provides the core MT5 client,
-dataframe/trading primitives, and canonical MT5 constant parsing. mt5api adds
-optional API-key auth and JSON/Parquet response formatting.
+mt5api exposes MT5 market data, account info, trading history, trading state,
+order validation, and operational terminal endpoints over HTTP. It is a
+FastAPI/HTTP adapter over [`pdmt5`](https://github.com/dceoy/pdmt5), which
+provides the core MT5 client, dataframe/order primitives, and canonical MT5
+constant parsing. mt5api adds optional API-key auth and JSON/Parquet response
+formatting.
+
+The exposed operational surface is deliberately narrow: mt5api validates trade
+requests, manages terminal-side subscriptions and MarketWatch visibility, and
+supports reconnecting the terminal to a different MT5 account via
+`POST /connection/login`, but it does not expose live order-send endpoints or
+implement strategy orchestration.
 
 The API server must run on Windows. pdmt5 connects through the MetaTrader 5
 Python API, which is supported only on Windows, so you must host `mt5api` on a
@@ -69,8 +76,8 @@ graph TB
 
 ## Features
 
-- REST endpoints for symbols, market data, account info, orders, history,
-  calculations, and trading operations
+- REST endpoints for symbols, market data, account info, orders, positions,
+  history, margin/profit calculations, order validation, and terminal operations
 - JSON and Apache Parquet responses (content negotiation)
 - Optional API key authentication
 - Structured JSON logging

{mt5api-1.0.0 → mt5api-1.0.1}/README.md

@@ -4,11 +4,18 @@ MetaTrader 5 REST API
 
 [![CI/CD](https://github.com/dceoy/mt5api/actions/workflows/ci.yml/badge.svg)](https://github.com/dceoy/mt5api/actions/workflows/ci.yml)
 
-mt5api exposes MT5 market data, account info, trading history, and trading
-operations over HTTP. It is a FastAPI/HTTP adapter over
-[`pdmt5`](https://github.com/dceoy/pdmt5), which provides the core MT5 client,
-dataframe/trading primitives, and canonical MT5 constant parsing. mt5api adds
-optional API-key auth and JSON/Parquet response formatting.
+mt5api exposes MT5 market data, account info, trading history, trading state,
+order validation, and operational terminal endpoints over HTTP. It is a
+FastAPI/HTTP adapter over [`pdmt5`](https://github.com/dceoy/pdmt5), which
+provides the core MT5 client, dataframe/order primitives, and canonical MT5
+constant parsing. mt5api adds optional API-key auth and JSON/Parquet response
+formatting.
+
+The exposed operational surface is deliberately narrow: mt5api validates trade
+requests, manages terminal-side subscriptions and MarketWatch visibility, and
+supports reconnecting the terminal to a different MT5 account via
+`POST /connection/login`, but it does not expose live order-send endpoints or
+implement strategy orchestration.
 
 The API server must run on Windows. pdmt5 connects through the MetaTrader 5
 Python API, which is supported only on Windows, so you must host `mt5api` on a
@@ -43,8 +50,8 @@ graph TB
 
 ## Features
 
-- REST endpoints for symbols, market data, account info, orders, history,
-  calculations, and trading operations
+- REST endpoints for symbols, market data, account info, orders, positions,
+  history, margin/profit calculations, order validation, and terminal operations
 - JSON and Apache Parquet responses (content negotiation)
 - Optional API key authentication
 - Structured JSON logging

{mt5api-1.0.0 → mt5api-1.0.1}/docs/api/rest-api.md

@@ -316,8 +316,8 @@ Errors follow RFC 7807 Problem Details:
 {
   "type": "/errors/validation-error",
   "title": "Request Validation Failed",
-  "status": 400,
-  "detail": "count must be positive (got: -10)",
+  "status": 422,
+  "detail": "Request validation error details",
   "instance": "/rates/from"
 }
 ```

{mt5api-1.0.0 → mt5api-1.0.1}/mt5api/__main__.py

@@ -11,11 +11,7 @@ from .config import (
     get_configured_api_log_level,
     get_configured_api_port,
 )
-from .constants import (
-    API_APP_IMPORT,
-    DEFAULT_API_PORT,
-    MAX_API_PORT,
-)
+from .constants import API_APP_IMPORT
 
 
 def _get_host() -> str:
@@ -33,19 +29,7 @@ def _get_port() -> int:
     Returns:
         Port number for the API server.
     """
-    raw_port = get_configured_api_port()
-    if raw_port is None:
-        return DEFAULT_API_PORT
-
-    try:
-        port_value = int(raw_port)
-    except ValueError:
-        return DEFAULT_API_PORT
-
-    if not 1 <= port_value <= MAX_API_PORT:
-        return DEFAULT_API_PORT
-
-    return port_value
+    return get_configured_api_port()
 
 
 def _get_log_level() -> str:
@@ -54,7 +38,7 @@ def _get_log_level() -> str:
     Returns:
         Log level string for uvicorn.
     """
-    return get_configured_api_log_level().lower()
+    return get_configured_api_log_level()
 
 
 def main() -> None:

{mt5api-1.0.0 → mt5api-1.0.1}/mt5api/config.py

@@ -8,6 +8,7 @@ import re
 from .constants import (
     DEFAULT_API_HOST,
     DEFAULT_API_LOG_LEVEL,
+    DEFAULT_API_PORT,
     DEFAULT_API_ROUTER_PREFIX,
     DEFAULT_MAX_MARKET_BOOK_SUBSCRIPTIONS,
     ENV_MT5API_HOST,
@@ -16,9 +17,21 @@ from .constants import (
     ENV_MT5API_PORT,
     ENV_MT5API_ROUTER_PREFIX,
     ENV_MT5API_SECRET_KEY,
+    MAX_API_PORT,
 )
 
 _VALID_API_ROUTER_PREFIX_PATTERN = re.compile(r"^[A-Za-z0-9_-]+(?:/[A-Za-z0-9_-]+)*$")
+_VALID_UVICORN_LOG_LEVELS = {"critical", "error", "warning", "info", "debug", "trace"}
+_LOGGING_LOG_LEVEL_BY_API_LEVEL = {
+    "critical": "CRITICAL",
+    "error": "ERROR",
+    "warning": "WARNING",
+    "info": "INFO",
+    "debug": "DEBUG",
+    "trace": "DEBUG",
+}
+_INVALID_MT5API_PORT_ERROR = "Invalid MT5API_PORT"
+_INVALID_MT5API_LOG_LEVEL_ERROR = "Invalid MT5API_LOG_LEVEL"
 _INVALID_MT5API_ROUTER_PREFIX_ERROR = "Invalid MT5API_ROUTER_PREFIX"
 _INVALID_MT5API_MAX_MARKET_BOOK_SUBSCRIPTIONS_ERROR = (
     "Invalid MT5API_MAX_MARKET_BOOK_SUBSCRIPTIONS"
@@ -59,22 +72,52 @@ def get_configured_api_host() -> str:
     return os.getenv(ENV_MT5API_HOST, DEFAULT_API_HOST)
 
 
-def get_configured_api_port() -> str | None:
-    """Get the configured API port string.
+def get_configured_api_port() -> int:
+    """Get the configured API port.
 
     Returns:
-        Raw port string from the environment, or ``None`` if unset.
+        Port number for the API server.
+
+    Raises:
+        ValueError: If the configured port is not an integer in the TCP port range.
     """
-    return os.getenv(ENV_MT5API_PORT)
+    raw_port = os.getenv(ENV_MT5API_PORT)
+    if raw_port is None:
+        return DEFAULT_API_PORT
+
+    try:
+        port = int(raw_port)
+    except ValueError as error:
+        raise ValueError(_INVALID_MT5API_PORT_ERROR) from error
+
+    if not 1 <= port <= MAX_API_PORT:
+        raise ValueError(_INVALID_MT5API_PORT_ERROR)
+
+    return port
 
 
 def get_configured_api_log_level() -> str:
     """Get the configured API log level.
 
     Returns:
-        Log level string from configuration.
+        Valid uvicorn log level string from configuration.
+
+    Raises:
+        ValueError: If the configured log level is unsupported.
+    """
+    log_level = os.getenv(ENV_MT5API_LOG_LEVEL, DEFAULT_API_LOG_LEVEL).strip().lower()
+    if log_level not in _VALID_UVICORN_LOG_LEVELS:
+        raise ValueError(_INVALID_MT5API_LOG_LEVEL_ERROR)
+    return log_level
+
+
+def get_configured_python_log_level() -> str:
+    """Get a stdlib logging-compatible log level for the API logger.
+
+    Returns:
+        Python logging level name derived from the configured API log level.
     """
-    return os.getenv(ENV_MT5API_LOG_LEVEL, DEFAULT_API_LOG_LEVEL)
+    return _LOGGING_LOG_LEVEL_BY_API_LEVEL[get_configured_api_log_level()]
 
 
 def get_configured_api_router_prefix() -> str:

{mt5api-1.0.0 → mt5api-1.0.1}/mt5api/constants.py

@@ -6,7 +6,7 @@ API_DESCRIPTION = (
     "Provides market data, account information, trading history, calculations, "
     "and safe operational endpoints via HTTP."
 )
-API_VERSION = "1.0.0"
+API_VERSION = "1.0.1"
 API_DOCS_URL = "/docs"
 API_REDOC_URL = "/redoc"
 API_OPENAPI_URL = "/openapi.json"

{mt5api-1.0.0 → mt5api-1.0.1}/mt5api/dependencies.py

@@ -80,12 +80,12 @@ def shutdown_mt5_client() -> None:
 async def replace_mt5_client(config: Mt5Config) -> Mt5DataClient:
     """Swap the MT5 client singleton with a new connection.
 
-    Constructs and initializes the new ``Mt5DataClient`` BEFORE touching the
-    singleton so a failed reconnect leaves the existing client in place
-    instead of disconnecting the operator from a working terminal. The new
-    client is installed atomically; the old client (if any) is shut down on
-    a best-effort basis after the swap. Callers MUST hold
-    ``get_mt5_client_lock`` so concurrent reconnect requests do not race.
+    Constructs and initializes the new ``Mt5DataClient`` before replacing the
+    singleton reference. The MetaTrader5 Python module has process-global
+    connection state, so the previous client object must not be shut down after
+    successful reconnect because that would close the connection just opened by
+    the new client. Callers MUST hold ``get_mt5_client_lock`` so concurrent
+    reconnect requests do not race.
 
     The raised ``RuntimeError`` deliberately omits the underlying exception
     text from its message because third-party ``pdmt5``/MetaTrader5
@@ -101,7 +101,7 @@ async def replace_mt5_client(config: Mt5Config) -> Mt5DataClient:
 
     Raises:
         RuntimeError: If the new MT5 client cannot be constructed or
-            initialized. The previously installed client is preserved.
+            initialized.
     """
     global _mt5_client  # noqa: PLW0603
 
@@ -113,15 +113,8 @@ async def replace_mt5_client(config: Mt5Config) -> Mt5DataClient:
         error_message = "Failed to initialize MT5 client"
         raise RuntimeError(error_message) from e
 
-    old_client = _mt5_client
     _mt5_client = new_client
 
-    if old_client is not None:
-        try:
-            await asyncio.to_thread(old_client.shutdown)
-        except Exception:
-            logger.exception("Failed to shutdown previous MT5 client")
-
     return new_client
 
 

{mt5api-1.0.0 → mt5api-1.0.1}/mt5api/main.py

@@ -13,9 +13,9 @@ from fastapi.openapi.utils import get_openapi
 
 from .auth import is_auth_enabled
 from .config import (
-    get_configured_api_log_level,
     get_configured_api_router_prefix,
     get_configured_max_market_book_subscriptions,
+    get_configured_python_log_level,
 )
 from .constants import (
     ACTIVE_MARKET_BOOK_SUBSCRIPTIONS_STATE_KEY,
@@ -31,6 +31,7 @@ from .constants import (
 )
 from .dependencies import release_market_book_subscriptions, shutdown_mt5_client
 from .middleware import add_middleware
+from .models import ErrorResponse
 from .routers import (
     account,
     calc,
@@ -65,7 +66,7 @@ class _JsonFormatter(logging.Formatter):
 
 def _configure_logging() -> None:
     """Configure structured logging for the API."""
-    log_level = get_configured_api_log_level().upper()
+    log_level = get_configured_python_log_level()
 
     handler = logging.StreamHandler()
     handler.setFormatter(_JsonFormatter())
@@ -96,6 +97,37 @@ def _strip_auth_from_openapi(openapi_schema: dict[str, Any]) -> None:
                 operation.pop("security", None)
 
 
+def _patch_validation_error_responses(openapi_schema: dict[str, Any]) -> None:
+    """Advertise RFC 7807 Problem Details for request validation failures."""
+    components = openapi_schema.setdefault("components", {})
+    if not isinstance(components, dict):
+        return
+
+    schemas = components.setdefault("schemas", {})
+    if isinstance(schemas, dict):
+        schemas["ErrorResponse"] = ErrorResponse.model_json_schema(
+            ref_template="#/components/schemas/{model}",
+        )
+        schemas.pop("HTTPValidationError", None)
+        schemas.pop("ValidationError", None)
+
+    error_response = {
+        "description": "Validation Error",
+        "content": {
+            "application/json": {
+                "schema": {"$ref": "#/components/schemas/ErrorResponse"},
+            },
+        },
+    }
+
+    for methods in openapi_schema.get("paths", {}).values():
+        if not isinstance(methods, dict):
+            continue
+        for operation in methods.values():
+            if isinstance(operation, dict) and "422" in operation.get("responses", {}):
+                operation["responses"]["422"] = error_response
+
+
 def _build_openapi_schema(app: FastAPI) -> dict[str, Any]:
     """Build OpenAPI schema for the current authentication mode.
 
@@ -113,6 +145,7 @@ def _build_openapi_schema(app: FastAPI) -> dict[str, Any]:
     )
     if not is_auth_enabled():
         _strip_auth_from_openapi(openapi_schema)
+    _patch_validation_error_responses(openapi_schema)
 
     app.openapi_schema = openapi_schema
     return openapi_schema

{mt5api-1.0.0 → mt5api-1.0.1}/mt5api/middleware.py

@@ -4,9 +4,10 @@ from __future__ import annotations
 
 import logging
 import time
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
-from fastapi import Request, status
+from fastapi import HTTPException, Request, status
+from fastapi.exceptions import RequestValidationError
 from fastapi.responses import JSONResponse
 from pdmt5.mt5 import Mt5RuntimeError
 from pydantic import ValidationError
@@ -14,6 +15,8 @@ from pydantic import ValidationError
 from .models import ErrorResponse
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from fastapi import FastAPI
     from starlette.middleware.base import RequestResponseEndpoint
     from starlette.responses import Response
@@ -21,6 +24,36 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+def _format_validation_error_location(location: Sequence[Any]) -> str:
+    """Format a Pydantic error location for display.
+
+    Args:
+        location: Pydantic validation error location tuple.
+
+    Returns:
+        Human-readable field path without the request-body prefix.
+    """
+    parts = [str(part) for part in location if str(part) != "body"]
+    return ".".join(parts) if parts else "request"
+
+
+def _format_request_validation_detail(exc: RequestValidationError) -> str:
+    """Build a sanitized validation detail string without echoing request input.
+
+    Args:
+        exc: FastAPI request validation error.
+
+    Returns:
+        Validation summary containing field paths and messages only.
+    """
+    details: list[str] = []
+    for error in exc.errors():
+        location = _format_validation_error_location(error.get("loc", ()))
+        message = str(error.get("msg", "Invalid value"))
+        details.append(f"{location}: {message}")
+    return "; ".join(details) if details else "Request validation failed"
+
+
 def _create_error_response(
     error_type: str,
     title: str,
@@ -162,11 +195,58 @@ async def logging_middleware(
     return response
 
 
+def http_exception_handler(
+    request: Request,
+    exc: HTTPException,
+) -> JSONResponse:
+    """Convert FastAPI HTTP exceptions to flat RFC 7807 responses.
+
+    Returns:
+        Problem Details JSON response.
+    """
+    if isinstance(exc.detail, dict):
+        detail = exc.detail.get("detail", str(exc.detail))
+        error_type = str(exc.detail.get("type", "/errors/http-error"))
+        title = str(exc.detail.get("title", "HTTP Error"))
+    else:
+        detail = str(exc.detail)
+        error_type = "/errors/http-error"
+        title = "HTTP Error"
+
+    return _create_error_response(
+        error_type,
+        title,
+        exc.status_code,
+        detail,
+        str(request.url),
+    )
+
+
+def request_validation_exception_handler(
+    request: Request,
+    exc: RequestValidationError,
+) -> JSONResponse:
+    """Convert FastAPI request validation failures to RFC 7807 responses.
+
+    Returns:
+        Problem Details JSON response.
+    """
+    return _create_error_response(
+        "/errors/validation-error",
+        "Request Validation Failed",
+        status.HTTP_422_UNPROCESSABLE_ENTITY,
+        _format_request_validation_detail(exc),
+        str(request.url),
+    )
+
+
 def add_middleware(app: FastAPI) -> None:
     """Add middleware and error handlers to the FastAPI application.
 
     Args:
         app: FastAPI application instance.
     """
+    app.exception_handler(HTTPException)(http_exception_handler)
+    app.exception_handler(RequestValidationError)(request_validation_exception_handler)
     app.middleware("http")(error_handler_middleware)
     app.middleware("http")(logging_middleware)

{mt5api-1.0.0 → mt5api-1.0.1}/mt5api/routers/connection.py

@@ -29,8 +29,8 @@ router = APIRouter(
     summary="Login to MT5 terminal",
     description=(
         "Reconnect the MT5 terminal using the supplied credentials. The current "
-        "MT5 client (if any) is shut down and any active market-book "
-        "subscriptions are released before the new connection is established."
+        "MT5 singleton is replaced after the new connection is established, then "
+        "any active market-book subscription tracking is cleared."
     ),
 )
 async def post_connection_login(
@@ -56,8 +56,8 @@ async def post_connection_login(
     )
 
     async with get_mt5_client_lock():
-        await release_market_book_subscriptions(app_request.app)
         await replace_mt5_client(config)
+        await release_market_book_subscriptions(app_request.app)
 
     logger.info(
         "MT5 client reconnected (login=%d, server=%s)",

{mt5api-1.0.0 → mt5api-1.0.1}/mt5api/routers/health.py

@@ -46,12 +46,12 @@ async def get_health() -> HealthResponse:
     mt5_version = None
 
     try:
-        client = get_mt5_client()
-        mt5_connected = True
+        client = await run_in_threadpool(get_mt5_client)
         version_dict = await run_in_threadpool(client.version_as_dict)
         if version_dict:
-            mt5_version = f"{version_dict.get('version', 'unknown')}"
-    except RuntimeError as e:
+            mt5_version = f"{version_dict.get('mt5_terminal_version', 'unknown')}"
+        mt5_connected = True
+    except Exception as e:  # noqa: BLE001
         logger.debug("MT5 not available for health check: %s", e)
 
     return HealthResponse(

{mt5api-1.0.0 → mt5api-1.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mt5api"
-version = "1.0.0"
+version = "1.0.1"
 description = "MetaTrader 5 REST API"
 authors = [{name = "dceoy", email = "dceoy@users.noreply.github.com"}]
 maintainers = [{name = "dceoy", email = "dceoy@users.noreply.github.com"}]
@@ -9,7 +9,7 @@ license-files = ["LICENSE"]
 readme = "README.md"
 requires-python = ">= 3.11, < 3.14"
 dependencies = [
-  "pdmt5 >= 1.0.1",
+  "pdmt5 >= 1.1.1",
   "fastapi >= 0.115.0",
   "uvicorn[standard] >= 0.32.0",
   "pyarrow >= 18.0.0",

{mt5api-1.0.0 → mt5api-1.0.1}/tests/conftest.py

@@ -44,9 +44,9 @@ def mock_mt5_client() -> Mock:
 
     # Mock version method
     client.version_as_dict.return_value = {
-        "version": "5.0.4321",
+        "mt5_terminal_version": "5.0.4321",
         "build": 4321,
-        "release_date": "2024-01-01",
+        "build_release_date": "2024-01-01",
     }
 
     # Mock account info