jesse 3.3.3__tar.gz → 3.3.4__tar.gz

{jesse-3.3.3/jesse.egg-info → jesse-3.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jesse
-Version: 3.3.3
+Version: 3.3.4
 Summary: A trading framework for cryptocurrencies
 Home-page: https://jesse.trade
 Author: Saleh Mir

{jesse-3.3.3 → jesse-3.3.4}/jesse/mcp/agent_rules.md

@@ -193,27 +193,45 @@ Code Generation:
 
 ### CRITICAL: Always surface the dashboard URL in every reply that reports a session
 
-Every backtest, optimization, Monte Carlo, and rule significance test
-response from the MCP carries a `dashboard_url` field. This is the single highest-
-leverage piece of information you give the user — one click and they
+Every backtest, optimization, Monte Carlo, rule significance test, and
+live/paper session response from the MCP carries a `dashboard_url` field. This is
+the single highest-leverage piece of information you give the user — one click and they
 see the equity curve, trades table, scenario charts, and everything
 else you can't fit in a chat reply.
 
+Where to find it:
+- Responses about one session (create/update draft, run, start, stop, cancel, notes,
+  `get_*_session`, and every `get_session_results` summary or section page): the
+  top-level `dashboard_url`.
+- Session lists (`get_backtest_sessions`, `get_optimization_sessions`,
+  `get_monte_carlo_sessions`, `get_significance_test_sessions`, `get_live_sessions`):
+  each session row has its own `dashboard_url`.
+- `get_live_trades` / `get_live_orders`: replace `{session_id}` in
+  `session_dashboard_url_template` with a record's `session_id`.
+
 You MUST include the dashboard URL whenever you mention a session in
 a user-facing reply. This is not optional. It applies to:
 - Final result summaries ("Backtest finished. Sharpe = …")
 - Interim progress updates ("Running, 40% done")
 - Error reports ("Stopped with exception …")
 - Iteration logs in optimization workflows
+- Live/paper sessions you list, start, stop, or report on
 - The Markdown report file (see below)
 
+Lead with the link, not the ID. A session ID is of no use to the user on its own:
+when they ask for "the URL", "the link", or just "the one running on <exchange>",
+the answer starts with the dashboard link of that session. If you only know the
+session from an earlier reply, call the list tool or `get_session_results` again to
+get its `dashboard_url` rather than answering with the ID.
+
 Format:
 - **Chat replies**: Markdown link using the exact `dashboard_url` value, e.g.
   `[View on dashboard](<dashboard_url>)`. Never rewrite its host or port;
   it already points at the address the user opens the dashboard from.
 - **Report file**: a `Dashboard:` line with the plain URL
 - If `dashboard_url` is empty in the response, say "dashboard URL
-  unavailable" — do NOT silently omit the line.
+  unavailable" — do NOT silently omit the line, and do NOT build one from a
+  host or port you guessed.
 
 Do not wait for the user to ask for the URL. If you just received a
 response with a `dashboard_url`, the URL goes in your next reply.

{jesse-3.3.3 → jesse-3.3.4}/jesse/mcp/mcp_config.py

@@ -8,7 +8,7 @@ are stored here to avoid circular imports.
 The worker entry point (jesse.mcp.server) sets these values before registering tools.
 """
 
-from typing import Optional
+from typing import Any, Optional
 from urllib.parse import quote
 
 # Internal Jesse API URL. Tools call the API on this machine through it (loopback or the
@@ -83,3 +83,35 @@ def dashboard_url(category: str, session_id: str) -> str:
     if not path or not session_id:
         return ''
     return f"{DASHBOARD_URL}/#/{path}/{quote(str(session_id), safe='')}"
+
+
+def with_dashboard_urls(category: str, sessions: Any) -> Any:
+    """
+    Return the rows of a session list with each one's `dashboard_url` added (from its `id`).
+
+    The user asks for "the link to the one running on X" far more often than for an ID, so
+    every list a tool returns carries the links ready to use. Anything that is not a list of
+    session rows is returned unchanged.
+    """
+    if not isinstance(sessions, list):
+        return sessions
+    return [
+        {**row, 'dashboard_url': dashboard_url(category, row.get('id'))} if isinstance(row, dict) else row
+        for row in sessions
+    ]
+
+
+def dashboard_url_template(category: str) -> str:
+    """
+    The dashboard link of any session of a category, with a literal `{session_id}` placeholder.
+
+    For responses that name many sessions under a fixed size budget (the live history pages):
+    one constant-size field instead of a link per session. Session IDs are UUIDs, so they need
+    no escaping when they replace the placeholder.
+    """
+    if not DASHBOARD_URL:
+        return ''
+    path = _DASHBOARD_PATHS.get(category)
+    if not path:
+        return ''
+    return f"{DASHBOARD_URL}/#/{path}/{{session_id}}"

{jesse-3.3.3 → jesse-3.3.4}/jesse/mcp/resources/live_trading.md

@@ -48,6 +48,12 @@ session's saved credential values redacted. For a period across sessions ("my tr
 days"), use `get_live_trades` / `get_live_orders` (Jesse's records, not the exchange account's
 history; live only unless `mode` says otherwise). See `jesse://session_analysis`.
 
+Every one of these, like the tools above, returns the session's dashboard link: `dashboard_url` on
+a single session's response and on each row of `get_live_sessions()`, and
+`session_dashboard_url_template` (replace `{session_id}`) on the history pages. When the user asks
+for a session, or for its URL, answer with that link first; the session ID alone does not help
+them. Opening it loads the session into a dashboard Live tab.
+
 ## What stopping does
 
 Stopping asks the session process to end; a running session notices within about a second, one

{jesse-3.3.3 → jesse-3.3.4}/jesse/mcp/resources/session_analysis.md

@@ -38,6 +38,10 @@ get_session_results(session_type="backtest", session_id="<uuid>", section="trade
   find session IDs. `get_backtest_session` and the other `get_*_session` tools return the
   raw dashboard record, including every trade and curve point; prefer
   `get_session_results` for reading results.
+- Every successful `get_session_results` response (summary or section) has `dashboard_url`,
+  and every row of the list tools has its own. Give the user that link whenever you mention
+  a session, and lead with it when they ask for a session or its URL; the ID alone does not
+  help them.
 
 Live and paper sessions:
 - Readable only when the live trading plugin is installed and enabled

{jesse-3.3.3 → jesse-3.3.4}/jesse/mcp/server.py

@@ -57,6 +57,9 @@ INSTRUCTIONS = (
     "Read stored session results, including live/paper sessions, with get_session_results "
     "(summary first); Jesse's recorded live/paper trades and orders of a date window across "
     "sessions with get_live_trades / get_live_orders (not the exchange account's history). "
+    "Whenever you mention a session to the user, or they ask for its URL or link, give the "
+    "`dashboard_url` from the tool response as a link, before any other detail; a session ID "
+    "alone is of no use to them. "
     "To analyze, compare, or chart results, use run_analysis, which runs in a "
     "temporary workspace and never needs research_scripts/; see jesse://session_analysis."
 )

{jesse-3.3.3 → jesse-3.3.4}/jesse/mcp/tools/backtest.py

@@ -392,6 +392,7 @@ def register_backtest_tools(mcp):
                         "finish_date": "YYYY-MM-DD",
                         "total_trades": int,
                         "net_profit": float,
+                        "dashboard_url": "<dashboard origin>/#/backtest/uuid-string",
                         ...
                     }
                 ],

{jesse-3.3.3 → jesse-3.3.4}/jesse/mcp/tools/monte_carlo.py

@@ -274,6 +274,9 @@ def register_monte_carlo_tools(mcp):
             title_search: Case-insensitive substring on title.
             status_filter: One of "draft", "running", "finished", "stopped", "terminated".
             date_filter: One of "7_days", "30_days", "90_days".
+
+        Each session row has "dashboard_url", its page on the dashboard: give the user that
+        link, not the bare ID.
         """
         return await run_blocking(
             get_monte_carlo_sessions_service,

{jesse-3.3.3 → jesse-3.3.4}/jesse/mcp/tools/optimization.py

@@ -225,6 +225,9 @@ def register_optimization_tools(mcp):
             title_search: case-insensitive title substring.
             status_filter: "running" | "paused" | "finished" | "stopped" | "terminated".
             date_filter: "today" | "this_week" | "this_month" | "this_year".
+
+        Each session row has "dashboard_url", its page on the dashboard: give the user that
+        link, not the bare ID.
         """
         return await run_blocking(
             get_optimization_sessions_service,

{jesse-3.3.3 → jesse-3.3.4}/jesse/mcp/tools/services/backtest.py

@@ -452,6 +452,7 @@ def update_backtest_draft_service(backtest_id: str, state: str) -> dict:
                 'status': 'success',
                 'backtest_id': backtest_id,
                 'draft_state': state_dict,
+                'dashboard_url': mcp_config.dashboard_url('backtest', backtest_id),
                 'message': 'Backtest draft updated successfully'
             }
         elif response.status_code == 401:
@@ -541,6 +542,7 @@ def update_backtest_notes_service(
                 'description': description,
                 'strategy_code_keys': list(parsed_strategy_codes.keys()) if parsed_strategy_codes else [],
                 'strategy_codes_captured': len(parsed_strategy_codes) if parsed_strategy_codes else 0,
+                'dashboard_url': mcp_config.dashboard_url('backtest', session_id),
                 'message': 'Backtest session notes updated successfully'
             }
 
@@ -700,7 +702,7 @@ def get_backtest_sessions_service(
             data = response.json()
             return {
                 'status': 'success',
-                'sessions': data.get('sessions', []),
+                'sessions': mcp_config.with_dashboard_urls('backtest', data.get('sessions', [])),
                 'count': data.get('count', 0),
                 'message': f'Retrieved {data.get("count", 0)} backtest session(s)'
             }
@@ -890,6 +892,7 @@ def cancel_backtest_service(session_id: str) -> dict:
             return {
                 'status': 'success',
                 'session_id': session_id,
+                'dashboard_url': mcp_config.dashboard_url('backtest', session_id),
                 'message': f'Backtest {session_id} cancellation requested'
             }
         elif response.status_code == 401:

{jesse-3.3.3 → jesse-3.3.4}/jesse/mcp/tools/services/live.py

@@ -807,6 +807,7 @@ def update_live_session_notes_service(session_id: str, title: Optional[str] = No
         'session_id': session_id,
         'title': title,
         'description': description,
+        'dashboard_url': mcp_config.dashboard_url('live', session_id),
         'message': 'Session notes updated.',
     }
 

{jesse-3.3.3 → jesse-3.3.4}/jesse/mcp/tools/services/monte_carlo.py

@@ -330,6 +330,7 @@ def update_monte_carlo_draft_service(session_id: str, state: str) -> dict:
                 'status': 'success',
                 'session_id': session_id,
                 'draft_state': state_dict,
+                'dashboard_url': mcp_config.dashboard_url('monte_carlo', session_id),
                 'message': 'Monte Carlo draft updated successfully',
             }
         if response.status_code == 401:
@@ -371,6 +372,7 @@ def update_monte_carlo_notes_service(
                 'description': description,
                 'strategy_code_keys': list(parsed_codes.keys()) if parsed_codes else [],
                 'strategy_codes_captured': len(parsed_codes) if parsed_codes else 0,
+                'dashboard_url': mcp_config.dashboard_url('monte_carlo', session_id),
                 'message': 'Monte Carlo session notes updated successfully',
             }
         return result
@@ -448,7 +450,7 @@ def get_monte_carlo_sessions_service(
             data = response.json()
             return {
                 'status': 'success',
-                'sessions': data.get('sessions', []),
+                'sessions': mcp_config.with_dashboard_urls('monte_carlo', data.get('sessions', [])),
                 'count': data.get('count', 0),
                 'message': f'Retrieved {data.get("count", 0)} Monte Carlo session(s)',
             }
@@ -480,6 +482,7 @@ def get_monte_carlo_equity_curves_service(session_id: str) -> dict:
                 'session_id': session_id,
                 'trades': data.get('trades'),
                 'candles': data.get('candles'),
+                'dashboard_url': mcp_config.dashboard_url('monte_carlo', session_id),
                 'message': 'Equity curves retrieved successfully',
             }
         if response.status_code == 404:
@@ -511,6 +514,7 @@ def get_monte_carlo_logs_service(session_id: str) -> dict:
                 'status': 'success',
                 'session_id': session_id,
                 'logs': data.get('logs', ''),
+                'dashboard_url': mcp_config.dashboard_url('monte_carlo', session_id),
                 'message': 'Logs retrieved successfully',
             }
         if response.status_code == 404:
@@ -687,6 +691,7 @@ def cancel_monte_carlo_service(session_id: str) -> dict:
         )
         if response.status_code == 202:
             return {'status': 'success', 'session_id': session_id,
+                    'dashboard_url': mcp_config.dashboard_url('monte_carlo', session_id),
                     'message': f'Monte Carlo {session_id} cancellation requested'}
         if response.status_code == 401:
             return {'status': 'error', 'message': 'Authentication failed'}
@@ -712,6 +717,7 @@ def terminate_monte_carlo_service(session_id: str) -> dict:
         )
         if response.status_code == 202:
             return {'status': 'success', 'session_id': session_id,
+                    'dashboard_url': mcp_config.dashboard_url('monte_carlo', session_id),
                     'message': f'Monte Carlo {session_id} terminated'}
         if response.status_code == 401:
             return {'status': 'error', 'message': 'Authentication failed'}

{jesse-3.3.3 → jesse-3.3.4}/jesse/mcp/tools/services/optimization.py

@@ -330,6 +330,7 @@ def update_optimization_draft_service(session_id: str, state: str) -> dict:
                 'status': 'success',
                 'session_id': session_id,
                 'draft_state': state_dict,
+                'dashboard_url': mcp_config.dashboard_url('optimization', session_id),
                 'message': 'Optimization draft updated successfully',
             }
         if response.status_code == 401:
@@ -371,6 +372,7 @@ def update_optimization_notes_service(
                 'description': description,
                 'strategy_code_keys': list(parsed_codes.keys()) if parsed_codes else [],
                 'strategy_codes_captured': len(parsed_codes) if parsed_codes else 0,
+                'dashboard_url': mcp_config.dashboard_url('optimization', session_id),
                 'message': 'Optimization session notes updated successfully',
             }
         return result
@@ -448,7 +450,7 @@ def get_optimization_sessions_service(
             data = response.json()
             return {
                 'status': 'success',
-                'sessions': data.get('sessions', []),
+                'sessions': mcp_config.with_dashboard_urls('optimization', data.get('sessions', [])),
                 'count': data.get('count', 0),
                 'message': f'Retrieved {data.get("count", 0)} optimization session(s)',
             }
@@ -479,6 +481,7 @@ def get_optimization_logs_service(session_id: str) -> dict:
                 'status': 'success',
                 'session_id': session_id,
                 'logs': data.get('logs', ''),
+                'dashboard_url': mcp_config.dashboard_url('optimization', session_id),
                 'message': 'Logs retrieved successfully',
             }
         if response.status_code == 404:
@@ -687,6 +690,7 @@ def cancel_optimization_service(session_id: str) -> dict:
         )
         if response.status_code == 202:
             return {'status': 'success', 'session_id': session_id,
+                    'dashboard_url': mcp_config.dashboard_url('optimization', session_id),
                     'message': f'Optimization {session_id} cancellation requested'}
         if response.status_code == 401:
             return {'status': 'error', 'message': 'Authentication failed'}
@@ -712,6 +716,7 @@ def terminate_optimization_service(session_id: str) -> dict:
         )
         if response.status_code == 202:
             return {'status': 'success', 'session_id': session_id,
+                    'dashboard_url': mcp_config.dashboard_url('optimization', session_id),
                     'message': f'Optimization {session_id} terminated'}
         if response.status_code == 401:
             return {'status': 'error', 'message': 'Authentication failed'}

{jesse-3.3.3 → jesse-3.3.4}/jesse/mcp/tools/services/session_analysis.py

@@ -7,6 +7,7 @@ running Jesse, so these tools work the same when the assistant runs on another c
 """
 from typing import Any, List, Optional
 
+import jesse.mcp.mcp_config as mcp_config
 from .project_files import CANCEL_TIMEOUT_SECONDS, REQUEST_TIMEOUT_SECONDS, TRANSFER_TIMEOUT_SECONDS, _call
 
 # Result pages are bounded by the API (128 KiB of JSON), but a large Monte Carlo record is
@@ -14,47 +15,70 @@ from .project_files import CANCEL_TIMEOUT_SECONDS, REQUEST_TIMEOUT_SECONDS, TRAN
 RESULTS_TIMEOUT_SECONDS = 60
 
 
+def _succeeded(result: dict) -> bool:
+    return result.get('status') == 'success'
+
+
 def get_session_results_service(session_type: str, session_id: str, section: str = 'summary',
                                 offset: int = 0, limit: int = 50) -> dict:
-    return _call(
+    result = _call(
         'get_session_results', '/session-results/get',
         {'session_type': session_type, 'session_id': session_id, 'section': section, 'offset': offset, 'limit': limit},
         RESULTS_TIMEOUT_SECONDS,
     )
+    if _succeeded(result):
+        # From the type and ID the API echoes back (validated and normalized), so every summary and
+        # section page of an existing session carries its link. Page budgets cover the items only.
+        result['dashboard_url'] = mcp_config.dashboard_url(result.get('session_type'), result.get('session_id'))
+    return result
 
 
 def get_live_sessions_service(limit: int = 20, offset: int = 0, status_filter: Optional[str] = None,
                               mode_filter: Optional[str] = None, title_search: Optional[str] = None) -> dict:
-    return _call(
+    result = _call(
         'get_live_sessions', '/session-results/live-sessions',
         {'limit': limit, 'offset': offset, 'status_filter': status_filter, 'mode_filter': mode_filter,
          'title_search': title_search},
         RESULTS_TIMEOUT_SECONDS,
     )
+    if _succeeded(result):
+        result['sessions'] = mcp_config.with_dashboard_urls('live', result.get('sessions'))
+    return result
+
+
+def _with_session_link_template(result: dict) -> dict:
+    """
+    Add the live session link template to a history page. A page is cut to a byte budget on the
+    Jesse host (live_history.MAX_RESPONSE_BYTES), so it gets this one constant-size field, which
+    fits the budget's transport allowance, rather than a link per session.
+    """
+    if _succeeded(result):
+        result['session_dashboard_url_template'] = mcp_config.dashboard_url_template('live')
+    return result
 
 
 def get_live_trades_service(start: Any = None, end: Any = None, recent_days: Any = None, mode: Any = 'live',
                             exchange: Any = None, symbol: Any = None, session_id: Any = None,
                             order: Any = 'newest_first', cursor: Any = None, limit: Any = 100) -> dict:
-    return _call(
+    return _with_session_link_template(_call(
         'get_live_trades', '/session-results/live-trades',
         {'start': start, 'end': end, 'recent_days': recent_days, 'mode': mode, 'exchange': exchange,
          'symbol': symbol, 'session_id': session_id, 'order': order, 'cursor': cursor, 'limit': limit},
         RESULTS_TIMEOUT_SECONDS,
-    )
+    ))
 
 
 def get_live_orders_service(start: Any = None, end: Any = None, recent_days: Any = None, mode: Any = 'live',
                             exchange: Any = None, symbol: Any = None, session_id: Any = None,
                             time_field: Any = 'created_at', status: Any = None, order: Any = 'newest_first',
                             cursor: Any = None, limit: Any = 100) -> dict:
-    return _call(
+    return _with_session_link_template(_call(
         'get_live_orders', '/session-results/live-orders',
         {'start': start, 'end': end, 'recent_days': recent_days, 'mode': mode, 'exchange': exchange,
          'symbol': symbol, 'session_id': session_id, 'time_field': time_field, 'status': status, 'order': order,
          'cursor': cursor, 'limit': limit},
         RESULTS_TIMEOUT_SECONDS,
-    )
+    ))
 
 
 def run_analysis_service(code: str, inputs: Optional[List[dict]] = None, timeout_minutes: int = 5) -> dict:

{jesse-3.3.3 → jesse-3.3.4}/jesse/mcp/tools/services/significance_test.py

@@ -258,6 +258,7 @@ def update_significance_test_draft_service(session_id: str, state: str) -> dict:
                 'status': 'success',
                 'session_id': session_id,
                 'draft_state': state_dict,
+                'dashboard_url': mcp_config.dashboard_url('significance_test', session_id),
                 'message': 'Significance test draft updated successfully',
             }
         if response.status_code == 401:
@@ -299,6 +300,7 @@ def update_significance_test_notes_service(
                 'description': description,
                 'strategy_code_keys': list(parsed_codes.keys()) if parsed_codes else [],
                 'strategy_codes_captured': len(parsed_codes) if parsed_codes else 0,
+                'dashboard_url': mcp_config.dashboard_url('significance_test', session_id),
                 'message': 'Significance test session notes updated successfully',
             }
         return result
@@ -376,7 +378,7 @@ def get_significance_test_sessions_service(
             data = response.json()
             return {
                 'status': 'success',
-                'sessions': data.get('sessions', []),
+                'sessions': mcp_config.with_dashboard_urls('significance_test', data.get('sessions', [])),
                 'count': data.get('count', 0),
                 'message': f'Retrieved {data.get("count", 0)} significance test session(s)',
             }
@@ -491,6 +493,7 @@ def cancel_significance_test_service(session_id: str) -> dict:
         )
         if response.status_code == 202:
             return {'status': 'success', 'session_id': session_id,
+                    'dashboard_url': mcp_config.dashboard_url('significance_test', session_id),
                     'message': f'Significance test {session_id} cancellation requested'}
         if response.status_code == 401:
             return {'status': 'error', 'message': 'Authentication failed'}

{jesse-3.3.3 → jesse-3.3.4}/jesse/mcp/tools/session_results.py

@@ -77,7 +77,9 @@ _HISTORY_COMMON = """
         your code the complete selection on the Jesse host in its own database view.
 
         Each record carries session_id; "sessions" describes the sessions on this page (title,
-        mode, exchange, status; {"exists": false} for a deleted one); "is_active" and a
+        mode, exchange, status; {"exists": false} for a deleted one). To link a session for the
+        user, replace {session_id} in "session_dashboard_url_template" with its ID ("" when
+        no dashboard URL is known; a deleted session has no page). "is_active" and a
         stopped status for a session left marked running come from Jesse's worker registry at
         that moment, best effort, not from the page's database view. Saved key and
         notification credential values are redacted per record's session (every saved key's
@@ -130,7 +132,9 @@ def register_session_results_tools(mcp):
             "session_id", "session_status", "status_note" (for unfinished runs), "title", "form",
             results, "error" (exception + traceback tail) and "sections"/"counts". For other
             sections: {"section", "items", "offset", "limit", "returned", "total",
-            "next_offset", "has_more", "truncated_by_size"}. Values are exactly as stored;
+            "next_offset", "has_more", "truncated_by_size"}. Every successful response, summary
+            or section, also has "dashboard_url": the session's page on the dashboard. Give the
+            user that link, not the bare session ID. Values are exactly as stored;
             NaN/infinite numbers are null. Errors: {"status": "error", "error_type", "message"}
             with error_type "not_found", "invalid_request", "item_too_large" (use
             run_analysis), "offset_too_large", "live_plugin_unavailable" (live sessions need
@@ -161,9 +165,11 @@ def register_session_results_tools(mcp):
         Returns:
             dict: {"status": "success", "sessions": [{"id", "title", "status", "is_active",
             "session_mode", "exchange", "routes", "created_at", "updated_at", "finished_at",
-            "has_error"}], "next_offset"} or an error with error_type
-            "live_plugin_unavailable" or "invalid_request". Read one with
-            get_session_results(session_type="live", session_id=...).
+            "has_error", "dashboard_url"}], "next_offset"} or an error with error_type
+            "live_plugin_unavailable" or "invalid_request". "dashboard_url" opens that session
+            on the dashboard: when the user asks for a session or its link, answer with it, not
+            with the bare ID. Read one with get_session_results(session_type="live",
+            session_id=...).
         """
         return await run_blocking(get_live_sessions_service, limit, offset, status_filter, mode_filter, title_search)
 
@@ -197,7 +203,8 @@ def register_session_results_tools(mcp):
             dict: {"status": "success", "dataset": "live_trades", "source", "range",
             "filters", "order", "items", "limit", "returned", "total", "has_more",
             "truncated_by_size", "truncated_by_orders", "all_records_returned", "next_page",
-            "sessions", "open_trades_not_included", "note", "paging"} or an error with
+            "sessions", "session_dashboard_url_template", "open_trades_not_included", "note",
+            "paging"} or an error with
             error_type "invalid_request", "invalid_cursor", "mode_mismatch",
             "too_many_orders" (a trade with over 10,000 executed orders), "item_too_large",
             "live_plugin_unavailable", "read_failed", "authentication_failed", or
@@ -230,8 +237,8 @@ def register_session_results_tools(mcp):
             dict: {"status": "success", "dataset": "live_orders", "source", "range",
             "filters", "order", "items", "limit", "returned", "total", "has_more",
             "truncated_by_size", "truncated_by_orders" (always false), "all_records_returned",
-            "next_page", "sessions", "counts_by_status", "note", "paging"} or an error like
-            get_live_trades.
+            "next_page", "sessions", "session_dashboard_url_template", "counts_by_status",
+            "note", "paging"} or an error like get_live_trades.
         """
     mcp.tool()(get_live_orders)
     # A misspelled filter must be refused, not dropped, and the text "null" must stay text: either

{jesse-3.3.3 → jesse-3.3.4}/jesse/mcp/tools/significance_test.py

@@ -221,6 +221,8 @@ def register_significance_test_tools(mcp):
 
         Returns:
             { "status": "success", "sessions": [...], "count": int, "message": ... }
+            Each session row has "dashboard_url", its page on the dashboard: give the user
+            that link, not the bare ID.
         """
         return await run_blocking(
             get_significance_test_sessions_service,

{jesse-3.3.3 → jesse-3.3.4}/jesse/services/live_history.py

@@ -81,7 +81,8 @@ MAX_LIMIT = session_results.MAX_LIMIT
 # the JSON-RPC message. Same 128 KiB (~30k tokens) budget as get_session_results pages.
 MAX_RESPONSE_BYTES = 128 * 1024
 # Reserved within that budget for what wraps the page after it is built: the route's "status",
-# the MCP service's "action" and "location" (~130 bytes), the JSON-RPC result object (~120
+# the MCP service's "action", "location" (~130 bytes), and "session_dashboard_url_template" (one
+# link, up to ~350 bytes for the longest valid DASHBOARD_URL), the JSON-RPC result object (~120
 # bytes), and SSE framing (~25 bytes).
 TRANSPORT_ALLOWANCE = 2 * 1024
 # Cursors are small base64url JSON objects (~140 characters); anything longer is not one.

jesse-3.3.4/jesse/version.py

@@ -0,0 +1 @@
+__version__ = "3.3.4"

{jesse-3.3.3 → jesse-3.3.4/jesse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jesse
-Version: 3.3.3
+Version: 3.3.4
 Summary: A trading framework for cryptocurrencies
 Home-page: https://jesse.trade
 Author: Saleh Mir

{jesse-3.3.3 → jesse-3.3.4}/tests/test_dashboard_url.py

@@ -217,3 +217,87 @@ def test_session_tools_call_internal_api_but_link_to_public_dashboard(
 
     assert requested_urls == [f'http://127.0.0.1:9000/{api_path}/sessions/session-id']
     assert result['dashboard_url'] == f'https://jesse.example.com/#/{route}/session-id'
+
+
+def test_session_rows_get_their_own_dashboard_link(monkeypatch):
+    monkeypatch.setattr(mcp_config, 'DASHBOARD_URL', 'https://jesse.example.com')
+    rows = [{'id': 'abc-123', 'title': 'one'}, {'title': 'no id'}, 'not a row']
+
+    assert mcp_config.with_dashboard_urls('live', rows) == [
+        {'id': 'abc-123', 'title': 'one', 'dashboard_url': 'https://jesse.example.com/#/live/abc-123'},
+        {'title': 'no id', 'dashboard_url': ''},
+        'not a row',
+    ]
+    assert rows[0] == {'id': 'abc-123', 'title': 'one'}
+    assert mcp_config.with_dashboard_urls('live', None) is None
+
+
+def test_dashboard_link_template_keeps_a_literal_session_id_placeholder(monkeypatch):
+    monkeypatch.setattr(mcp_config, 'DASHBOARD_URL', 'https://jesse.example.com')
+    template = mcp_config.dashboard_url_template('live')
+    assert template == 'https://jesse.example.com/#/live/{session_id}'
+    assert template.replace('{session_id}', 'abc-123') == mcp_config.dashboard_url('live', 'abc-123')
+    assert mcp_config.dashboard_url_template('unknown') == ''
+
+    monkeypatch.setattr(mcp_config, 'DASHBOARD_URL', None)
+    assert mcp_config.dashboard_url_template('live') == ''
+
+
+SESSION_SERVICES = [
+    (backtest_service, 'backtest', 'backtest'),
+    (optimization_service, 'optimization', 'optimization'),
+    (monte_carlo_service, 'monte_carlo', 'monte-carlo'),
+    (significance_test_service, 'significance_test', 'significance-test'),
+]
+
+
+def _fake_api(monkeypatch, service, status_code: int, payload: dict) -> None:
+    monkeypatch.setattr(mcp_config, 'JESSE_API_URL', 'http://127.0.0.1:9000')
+    monkeypatch.setattr(mcp_config, 'JESSE_PASSWORD', 'test-password')
+    monkeypatch.setattr(mcp_config, 'DASHBOARD_URL', 'https://jesse.example.com')
+    monkeypatch.setattr(
+        service.requests, 'post',
+        lambda _url, **_kwargs: SimpleNamespace(status_code=status_code, text='', json=lambda: payload),
+    )
+
+
+@pytest.mark.parametrize(('service', 'name', 'route'), SESSION_SERVICES)
+def test_session_lists_link_every_row_to_the_public_dashboard(monkeypatch, service, name, route):
+    _fake_api(monkeypatch, service, 200, {'sessions': [{'id': 'first'}, {'id': 'second'}], 'count': 2})
+
+    result = getattr(service, f'get_{name}_sessions_service')()
+
+    assert [row['dashboard_url'] for row in result['sessions']] == [
+        f'https://jesse.example.com/#/{route}/first', f'https://jesse.example.com/#/{route}/second',
+    ]
+
+
+@pytest.mark.parametrize(('service', 'name', 'route'), SESSION_SERVICES)
+def test_cancelling_a_session_still_returns_its_dashboard_link(monkeypatch, service, name, route):
+    _fake_api(monkeypatch, service, 202, {})
+
+    result = getattr(service, f'cancel_{name}_service')('session-id')
+
+    assert result['status'] == 'success'
+    assert result['dashboard_url'] == f'https://jesse.example.com/#/{route}/session-id'
+
+
+@pytest.mark.parametrize(
+    ('service', 'function_name', 'payload', 'route'),
+    [
+        (optimization_service, 'get_optimization_logs_service', {'logs': 'line'}, 'optimization'),
+        (optimization_service, 'terminate_optimization_service', {}, 'optimization'),
+        (monte_carlo_service, 'get_monte_carlo_logs_service', {'logs': 'line'}, 'monte-carlo'),
+        (monte_carlo_service, 'get_monte_carlo_equity_curves_service', {'trades': [], 'candles': []}, 'monte-carlo'),
+        (monte_carlo_service, 'terminate_monte_carlo_service', {}, 'monte-carlo'),
+    ],
+)
+def test_other_single_session_reads_and_actions_return_the_dashboard_link(
+    monkeypatch, service, function_name, payload, route,
+):
+    _fake_api(monkeypatch, service, 202 if function_name.startswith('terminate') else 200, payload)
+
+    result = getattr(service, function_name)('session-id')
+
+    assert result['status'] == 'success'
+    assert result['dashboard_url'] == f'https://jesse.example.com/#/{route}/session-id'