v5.0.4

Signed-off-by: TIANHE <TIANHE@GMAIL.COM>

Author: tianhe

.env.example

@@ -92,5 +92,5 @@
 # BACKEND_TAG=5.0.1
 #
 # Override the GHCR image paths (e.g. for forks):
-# BACKEND_IMAGE=ghcr.io/brokermr810/quantdinger-backend
-# FRONTEND_IMAGE=ghcr.io/brokermr810/quantdinger-frontend
+# BACKEND_IMAGE=ghcr.io/openbyteinc/quantdinger-backend
+# FRONTEND_IMAGE=ghcr.io/openbyteinc/quantdinger-frontend

CONTRIBUTING.md

@@ -102,7 +102,7 @@ This repository contains:
 - `backend_api_python/`: Flask backend + strategy runtime
 - `docker-compose.yml` / `docker-compose.ghcr.yml`: deployment stacks
 
-The web UI source lives in the separate private **QuantDinger-Vue** repo, which publishes `ghcr.io/brokermr810/quantdinger-frontend` to GHCR on every `v*` tag — both Compose files pull that image directly.
+The web UI source lives in the separate private **QuantDinger-Vue** repo, which publishes `ghcr.io/openbyteinc/quantdinger-frontend` to GHCR on every `v*` tag — both Compose files pull that image directly.
 
 ### Backend (Python)
 
@@ -115,7 +115,7 @@ python run.py
 
 ### Frontend
 
-The SPA lives in the private **QuantDinger-Vue** repo. Tagging a release there (`git tag vX.Y.Z && git push --tags`) triggers `.github/workflows/release-frontend.yml`, which builds a multi-arch image and pushes it to `ghcr.io/brokermr810/quantdinger-frontend`. No frontend artefacts are committed here — pin the consumed tag via `IMAGE_TAG` (or `FRONTEND_TAG` for a per-side override) in a root-level `.env`.
+The SPA lives in the private **QuantDinger-Vue** repo. Tagging a release there (`git tag vX.Y.Z && git push --tags`) triggers `.github/workflows/release-frontend.yml`, which builds a multi-arch image and pushes it to `ghcr.io/openbyteinc/quantdinger-frontend`. No frontend artefacts are committed here — pin the consumed tag via `IMAGE_TAG` (or `FRONTEND_TAG` for a per-side override) in a root-level `.env`.
 
 For local iteration without publishing, clone the Vue repo into `./QuantDinger-Vue/` (gitignored) and run `docker compose -f docker-compose.yml -f docker-compose.build.yml up --build` — see **DEVELOPMENT.md → Building frontend from local source**.
 

DEVELOPMENT.md

@@ -81,7 +81,7 @@ git tag v5.0.1
 git push origin v5.0.1
 ```
 
-The `release-frontend.yml` workflow there builds `linux/amd64 + linux/arm64` images via buildx and pushes them to `ghcr.io/brokermr810/quantdinger-frontend`, tagged with the semver value, `{major}.{minor}`, and `latest`.
+The `release-frontend.yml` workflow there builds `linux/amd64 + linux/arm64` images via buildx and pushes them to `ghcr.io/openbyteinc/quantdinger-frontend`, tagged with the semver value, `{major}.{minor}`, and `latest`.
 
 This repo's `docker-compose.yml` (and `docker-compose.ghcr.yml`) references that image by default. To pin a version while testing:
 

backend_api_python/app/services/ai_generation_contracts.py

@@ -21,22 +21,27 @@
 
 ## Event model
 - CTA strategies implement `handle_data(context, data)`.
-- Portfolio strategies normally register `run_daily`, `run_weekly`, or `run_monthly` callbacks in `initialize` and rebalance inside the callback.
+- Single-symbol signal strategies normally implement `handle_data(context, data)`. Do not add a schedule unless the user requests one or the strategy is explicitly a periodic portfolio rebalance.
+- Portfolio strategies may register the global helpers `run_daily(callback, time="HH:MM")`, `run_weekly(callback, weekday=1, time="HH:MM")`, or `run_monthly(callback, monthday=1, time="HH:MM")` in `initialize` and rebalance inside the callback. These are runtime-bound global helpers; call them directly and never as `context.run_daily`, `context.run_weekly`, or `context.run_monthly`.
 - Optional lifecycle handlers are `before_trading_start(context, data)` and `after_trading_end(context, data)`.
 - Store per-run state on the global `g` namespace.
 - Confirm decisions from visible completed data only. Never read future rows, use negative shifts, or otherwise introduce look-ahead bias.
 
 ## Data and factors
-- Use `get_history(count, frequency, field, security_list)` or `history(...)` for historical bars.
+- Historical-bar signatures are exact: `get_history(count, frequency=None, field=None, security_list=None)` and `data.history(symbols, count, fields=None)`.
+- In `get_history(...)`, `count` is always the first argument and must be an integer. In `data.history(...)`, symbols are first and the integer count is second. Prefer explicit keywords when using `data.history`, for example `data.history(symbol, count=60, fields=["close"])`.
+- A history request for one symbol returns a pandas `DataFrame` directly. Use `bars["close"]`; never index the result again with `bars[symbol]`. Multiple-symbol requests return a dictionary keyed by canonical symbol.
 - Use `indicator(name, symbol, **params)`, `factor(name, symbol, **params)`, or `get_factors(symbols, names, **params)` for technical factors.
 - TA-Lib indicators and factors are available through the registered 129-function adapter; use canonical TA-Lib names and valid parameters.
 - Use `get_fundamentals(fields, symbols)` only for real point-in-time fundamental fields supported by the platform. Do not invent fields or use future reports.
 - Use `get_index_stocks(reference)` for dynamic index constituents.
 - Use `get_universe_stocks()` for the currently selected platform universe pool. Do not copy pool constituents into source code.
 
 ## Orders and positions
-- Use `order`, `order_value`, `order_target`, `order_target_value`, or `order_target_percent`.
-- Use `get_position(symbol)` or `get_positions(...)` to inspect holdings.
+- Order-helper signatures are exact: `order(symbol, amount)`, `order_value(symbol, value)`, `order_target(symbol, amount)`, `order_target_value(symbol, value)`, and `order_target_percent(symbol, percent)`.
+- These are runtime-bound global helpers. Never pass `context` as their first argument. Optional execution and protection values must be keyword arguments after the two required arguments.
+- `get_position(symbol)` returns a `Position` object. Read `position.amount`, `position.avg_cost`, and `position.last_price` directly; never use dictionary membership, subscripting, `.get(...)`, or `getattr(...)` on it.
+- Use `get_positions(...)` when a dictionary of multiple positions is required.
 - Values passed to value-based order APIs are quote-currency exposure targets. Keep sizing bounded by available capital and explicit allocation rules.
 - Keep long entry, long exit, short entry, and short exit conditions independent. A bearish long exit is not automatically a short entry.
 - Spot and all non-crypto markets are long-only for now.
@@ -54,17 +59,6 @@
 - Do not use `eval`, `exec`, `compile`, `open`, `getattr`, `setattr`, dunder access, or unsafe imports.
 """
 
-INDICATOR_TO_STRATEGY_CONTRACT = """# Indicator-to-Strategy API V2 conversion
-
-- Convert the indicator's signal meaning into Strategy API V2 source with `initialize(context)` and executable handlers.
-- Remove chart-only `output`, plot, layer, and marker structures from the result.
-- Preserve event algebra and recursive indicator semantics without look-ahead.
-- Preserve the source timeframe in `context.subscribe(...)` when it is declared by the source; otherwise choose a conservative strategy-owned default.
-- Map an explicit bullish entry to a long entry and an explicit bearish exit to a long exit. Do not invent short, leverage, reversal, grid, DCA, or martingale behavior.
-- Add short logic only when the user explicitly requests it and supplies a distinct bearish entry rule.
-- Keep visual-only colors, label offsets, and layout parameters out of executable code.
-"""
-
 SCRIPT_STRATEGY_QUICK_TOOL_SYSTEM_PROMPT = SCRIPT_STRATEGY_SYSTEM_PROMPT + """
 
 # Homepage quick-tool entry
@@ -73,24 +67,17 @@
 - Do not return a research memo, checklist, or pseudo-code.
 """
 
-INDICATOR_TO_STRATEGY_SYSTEM_PROMPT = (
-    SCRIPT_STRATEGY_SYSTEM_PROMPT
-    + "\n\n"
-    + INDICATOR_TO_STRATEGY_CONTRACT
-    + """
-
-# Indicator conversion entry
-- The generated source may be saved directly and must compile as Strategy API V2.
-- Preserve the source indicator's visible signal meaning before adding execution behavior.
-"""
-)
-
 SCRIPT_STRATEGY_REPAIR_REQUIREMENTS = """# Strategy API V2 repair requirements
 - Return Python source only.
 - Require a metadata docstring and `initialize(context)`.
 - Require a source-owned universe and subscription.
 - Require at least one executable handler or registered schedule callback.
 - Use only Strategy API V2 data, factor, fundamental, position, and order APIs.
+- Prefer `handle_data(context, data)` for single-symbol signal strategies. Use schedules only for an explicitly requested schedule or periodic portfolio rebalance.
+- Schedule helpers are global calls: `run_daily(callback, time="HH:MM")`, `run_weekly(callback, weekday=1, time="HH:MM")`, and `run_monthly(callback, monthday=1, time="HH:MM")`. Never call them through `context`.
+- Enforce exact history signatures: `get_history(count, frequency, field, security_list)` and `data.history(symbols, count, fields)`. A single-symbol result is already a DataFrame.
+- Enforce exact order signatures such as `order_target_percent(symbol, percent)` and never pass `context` to a global order helper.
+- Treat `get_position(symbol)` as a `Position` object with direct `.amount`, `.avg_cost`, and `.last_price` attributes. Never treat it as a dictionary or use `getattr`.
 - Preserve completed-data-only execution and remove look-ahead.
 - Keep symbol, market, frequency, schedule, and universe in source code.
 - Permit user-adjustable leverage only for Crypto `@swap` instruments and only after `context.allow_leverage(max_leverage=N)`.

backend_api_python/app/services/llm.py

@@ -17,6 +17,15 @@
 logger = get_logger(__name__)
 
 
+class LLMAPIError(ValueError):
+    """Provider HTTP error with status and request metadata preserved."""
+
+    def __init__(self, message: str, *, status_code: int, request_id: str = ""):
+        super().__init__(message)
+        self.status_code = status_code
+        self.request_id = request_id
+
+
 class LLMProvider(Enum):
     """Supported LLM providers"""
     OPENROUTER = "openrouter"
@@ -305,18 +314,22 @@ def _call_openai_compatible(self, messages: list, model: str, temperature: float
 
         # Handle non-2xx with provider/model-aware details
         if response.status_code >= 400:
-            provider_name = "OpenRouter" if "openrouter" in (base_url or "").lower() else "LLM"
-            error_msg = f"{provider_name} API {response.status_code}"
-            err_text = ""
-            try:
-                error_data = response.json() or {}
-                error_detail = error_data.get("error")
-                if isinstance(error_detail, dict):
-                    err_text = str(error_detail.get("message") or "").strip()
-                elif isinstance(error_detail, str):
-                    err_text = error_detail.strip()
-            except Exception:
-                err_text = (response.text or "").strip()[:300]
+            normalized_base_url = (base_url or "").lower()
+            if "atlascloud" in normalized_base_url:
+                provider_name = "AtlasCloud"
+            elif "openrouter" in normalized_base_url:
+                provider_name = "OpenRouter"
+            else:
+                provider_name = "LLM"
+            err_text = self._extract_provider_error(response)
+            request_id = self._provider_request_id(response)
+            metadata = [f"model={model}"]
+            if request_id:
+                metadata.append(f"request_id={request_id}")
+            error_msg = (
+                f"{provider_name} API {response.status_code} "
+                f"({', '.join(metadata)})"
+            )
 
             if err_text:
                 error_msg = f"{error_msg}: {err_text}"
@@ -331,7 +344,11 @@ def _call_openai_compatible(self, messages: list, model: str, temperature: float
                 elif response.status_code == 404:
                     error_msg += ". 可能原因：模型不可用或账户隐私/数据策略限制。请检查 https://openrouter.ai/settings/privacy"
 
-            raise ValueError(error_msg)
+            raise LLMAPIError(
+                error_msg,
+                status_code=response.status_code,
+                request_id=request_id,
+            )
 
         result = response.json()
         if "choices" in result and len(result["choices"]) > 0:
@@ -342,6 +359,64 @@ def _call_openai_compatible(self, messages: list, model: str, temperature: float
         else:
             raise ValueError("API response is missing 'choices'")
 
+    @staticmethod
+    def _provider_request_id(response) -> str:
+        headers = getattr(response, "headers", None) or {}
+        for name in (
+            "x-request-id",
+            "request-id",
+            "x-correlation-id",
+            "cf-ray",
+        ):
+            value = headers.get(name) or headers.get(name.title())
+            if value:
+                return str(value).strip()[:200]
+        return ""
+
+    @classmethod
+    def _extract_provider_error(cls, response) -> str:
+        payload = None
+        try:
+            payload = response.json()
+        except Exception:
+            pass
+
+        detail = cls._format_provider_error_value(payload)
+        if not detail:
+            detail = str(getattr(response, "text", "") or "").strip()
+        return " ".join(detail.split())[:1000]
+
+    @classmethod
+    def _format_provider_error_value(cls, value) -> str:
+        if isinstance(value, str):
+            return value.strip()
+        if isinstance(value, list):
+            parts = [cls._format_provider_error_value(item) for item in value]
+            return "; ".join(part for part in parts if part)
+        if not isinstance(value, dict):
+            return ""
+
+        parts = []
+        location = value.get("loc") or value.get("location")
+        if isinstance(location, (list, tuple)):
+            location = ".".join(str(item) for item in location)
+        if location:
+            parts.append(str(location).strip())
+
+        for key in ("error", "message", "msg", "detail", "reason"):
+            if key not in value:
+                continue
+            text = cls._format_provider_error_value(value.get(key))
+            if text and text not in parts:
+                parts.append(text)
+
+        if not parts:
+            for key in ("code", "type", "status"):
+                item = value.get(key)
+                if isinstance(item, (str, int, float)) and str(item).strip():
+                    parts.append(f"{key}={item}")
+        return ": ".join(parts)
+
     def _call_google_gemini(self, messages: list, model: str, temperature: float,
                            api_key: str, base_url: str, timeout: int) -> str:
         """Call Google Gemini API."""
@@ -707,6 +782,46 @@ def call_llm_api(self, messages: list, model: str = None, temperature: float = 0
                         use_json_mode=use_json_mode
                     )
 
+            except LLMAPIError as e:
+                status_code = e.status_code
+                last_status_code = status_code
+                last_error = str(e)
+                logger.warning(
+                    "%s API HTTP error (%s): %s",
+                    p.value,
+                    current_model,
+                    e,
+                )
+
+                if (
+                    status_code in (402, 403)
+                    and try_alternative_providers
+                    and current_model == models_to_try[-1]
+                ):
+                    logger.warning(
+                        "%s returned %s. Trying alternative providers...",
+                        p.value,
+                        status_code,
+                    )
+                    return self._try_alternative_providers(
+                        messages,
+                        original_model,
+                        temperature,
+                        use_json_mode,
+                        excluded_provider=p,
+                    )
+
+                if not use_fallback or current_model == models_to_try[-1]:
+                    raise
+
+                logger.warning(
+                    "%s returned %s for model %s; trying fallback model...",
+                    p.value,
+                    status_code,
+                    current_model,
+                )
+                continue
+
             except requests.exceptions.HTTPError as e:
                 error_detail = e.response.text if e.response else str(e)
                 status_code = e.response.status_code if e.response else None