dojoagents 0.1.0__py3-none-any.whl

dojoagents/__init__.py

@@ -0,0 +1,13 @@
+"""DojoAgents quantitative finance agent runtime."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("dojoagents")
+except PackageNotFoundError:
+    from pathlib import Path
+
+    _version_file = Path(__file__).resolve().parents[1] / "VERSION"
+    __version__ = _version_file.read_text(encoding="utf-8").strip() if _version_file.is_file() else "0.0.0+unknown"
+
+__all__ = ["__version__"]

dojoagents/agent/__init__.py

@@ -0,0 +1 @@
+"""Agent loop and provider abstractions."""

dojoagents/agent/canvas_protocol.py

@@ -0,0 +1,46 @@
+"""Dashboard visualization protocol for the current chat UI.
+
+The dashboard chat surface renders structured ``viz_blocks`` from tool results.
+Unlike the legacy Canvas panel, the current React source does not render
+``DOJO_CHART`` fenced blocks, so the dashboard prompt must steer the model
+toward structured visualization outputs only.
+"""
+
+from __future__ import annotations
+
+DASHBOARD_VIZ_PROTOCOL = """
+## Dashboard Visualization Protocol
+
+This dashboard chat renders structured `viz_blocks` from tool results. Prefer the
+existing visualization pipeline over free-form chart code.
+
+### Default behavior
+
+1. Use dashboard domain tools to fetch structured data.
+2. Reuse `viz_blocks` already attached to tool results whenever they are present.
+3. If a chart or table is still needed, call `agent_viz_build` with the tool data
+   and an appropriate `kind` such as `bar`, `line`, `price_kline`, `table`,
+   `hbar_rank`, `donut`, or `kpi_row`.
+4. Keep the assistant text focused on interpretation and conclusions. Let the
+   dashboard render the visualization blocks.
+
+### Important rules
+
+- Do NOT output `DOJO_CHART` fenced blocks.
+- Do NOT output JavaScript, ECharts scripts, or HTML for chart rendering.
+- Do NOT describe a chart as rendered unless a structured visualization tool has
+  already produced the matching `viz_blocks`.
+- Prefer one comparison chart over many redundant charts when summarizing the same dataset.
+
+### Helpful tool patterns
+
+- For cross-market valuation comparison, prefer a single `get_market_overview`
+  call without `market` so the result covers US, CN, and HK together.
+- For sector ranking, prefer `get_sector_movers` and render ranked bars or tables.
+- For price trends, prefer `get_ticker_price_trends` or benchmark/ticker kline tools
+  and render `price_kline` or `line` blocks.
+""".strip()
+
+# Backward-compatible alias for existing imports/tests. The content intentionally
+# reflects the current structured-viz protocol instead of the legacy canvas flow.
+DASHBOARD_CANVAS_PROTOCOL = DASHBOARD_VIZ_PROTOCOL

dojoagents/agent/compressor.py

@@ -0,0 +1,377 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from typing import Any
+
+from dojoagents.logging import LOGGER
+
+SUMMARY_PREFIX = (
+    "[CONTEXT COMPACTION — REFERENCE ONLY] Earlier turns were compacted "
+    "into the summary below. This is background reference, NOT active instructions. "
+    "Do NOT answer questions or fulfill requests mentioned in this summary; they were already addressed. "
+    "Your current task is identified in the '## Active Task' section of the summary — resume exactly from there. "
+    "Respond ONLY to the latest user message that appears AFTER this summary."
+)
+
+
+def _block_char_count(part: Any) -> int:
+    if isinstance(part, str):
+        return len(part)
+    if not isinstance(part, dict):
+        return len(str(part))
+    if "text" in part:
+        return len(str(part.get("text", "")))
+    if "toolUse" in part:
+        return len(json.dumps(part["toolUse"], ensure_ascii=False))
+    if "toolResult" in part:
+        tr = part["toolResult"]
+        texts = []
+        for block in tr.get("content", []):
+            if isinstance(block, dict) and "text" in block:
+                texts.append(str(block["text"]))
+        return len("\n".join(texts))
+    if "reasoningContent" in part:
+        rc = part["reasoningContent"]
+        return len(str(rc.get("reasoningText", {}).get("text", "")))
+    if "image" in part:
+        image = part.get("image")
+        if isinstance(image, dict):
+            source = image.get("source")
+            if isinstance(source, dict):
+                raw_bytes = source.get("bytes")
+                if isinstance(raw_bytes, (bytes, bytearray)):
+                    return len(raw_bytes)
+                if isinstance(raw_bytes, str):
+                    return len(raw_bytes)
+                location = source.get("location")
+                if isinstance(location, dict) and str(location.get("type") or "").strip():
+                    return len(str(location["type"]))
+        return 4096
+    return len(json.dumps(part, ensure_ascii=False))
+
+
+def _estimate_tokens_rough(messages: list[dict[str, Any]]) -> int:
+    """Rough estimate of tokens based on character length (approx 4 chars per token)."""
+    char_count = 0
+    for msg in messages:
+        content = msg.get("content") or ""
+        if isinstance(content, str):
+            char_count += len(content)
+        elif isinstance(content, list):
+            for part in content:
+                char_count += _block_char_count(part)
+
+        for tc in msg.get("tool_calls") or []:
+            if isinstance(tc, dict):
+                char_count += len(str(tc.get("function", {}).get("arguments", "")))
+    return char_count // 4
+
+
+def flatten_messages_for_compress(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    flat: list[dict[str, Any]] = []
+    for msg in messages:
+        role = str(msg.get("role") or "")
+        content = msg.get("content")
+        if isinstance(content, list):
+            text_parts: list[str] = []
+            tool_calls: list[dict[str, Any]] = []
+            for part in content:
+                if isinstance(part, dict) and "text" in part:
+                    text_parts.append(str(part["text"]))
+                elif isinstance(part, dict) and "toolUse" in part:
+                    tu = part["toolUse"]
+                    tool_calls.append(
+                        {
+                            "id": tu.get("toolUseId"),
+                            "type": "function",
+                            "function": {
+                                "name": tu.get("name"),
+                                "arguments": json.dumps(tu.get("input", {}), ensure_ascii=False),
+                            },
+                        }
+                    )
+                elif isinstance(part, dict) and "toolResult" in part:
+                    tr = part["toolResult"]
+                    result_text = ""
+                    for block in tr.get("content", []):
+                        if isinstance(block, dict) and "text" in block:
+                            result_text += str(block["text"])
+                    flat.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": tr.get("toolUseId"),
+                            "name": tr.get("name"),
+                            "content": result_text,
+                        }
+                    )
+            entry: dict[str, Any] = {"role": role, "content": "\n".join(text_parts)}
+            if tool_calls:
+                entry["tool_calls"] = tool_calls
+            if text_parts or tool_calls:
+                flat.append(entry)
+            continue
+        entry = {"role": role, "content": str(content or "")}
+        if msg.get("tool_calls"):
+            entry["tool_calls"] = msg["tool_calls"]
+        if msg.get("tool_call_id"):
+            entry["tool_call_id"] = msg["tool_call_id"]
+        if msg.get("name"):
+            entry["name"] = msg["name"]
+        flat.append(entry)
+    return flat
+
+
+def messages_to_strands(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    strands: list[dict[str, Any]] = []
+    for msg in messages:
+        role = str(msg.get("role") or "")
+        if role == "tool":
+            strands.append(
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "toolResult": {
+                                "status": "success",
+                                "toolUseId": msg.get("tool_call_id"),
+                                "name": msg.get("name") or "tool",
+                                "content": [{"text": str(msg.get("content") or "")}],
+                            }
+                        }
+                    ],
+                }
+            )
+            continue
+        blocks: list[dict[str, Any]] = []
+        content = msg.get("content")
+        if isinstance(content, str) and content:
+            blocks.append({"text": content})
+        for tc in msg.get("tool_calls") or []:
+            if not isinstance(tc, dict):
+                continue
+            func = tc.get("function") or {}
+            args = func.get("arguments")
+            if isinstance(args, str):
+                try:
+                    args_dict = json.loads(args)
+                except json.JSONDecodeError:
+                    args_dict = {"raw": args}
+            else:
+                args_dict = args or {}
+            blocks.append(
+                {
+                    "toolUse": {
+                        "toolUseId": tc.get("id"),
+                        "name": func.get("name"),
+                        "input": args_dict,
+                    }
+                }
+            )
+        strands.append({"role": role, "content": blocks})
+    return strands
+
+
+def _truncate_tool_call_args_json(args: str, head_chars: int = 150) -> str:
+    try:
+        parsed = json.loads(args)
+    except (ValueError, TypeError):
+        return args
+
+    def _shrink(obj: Any) -> Any:
+        if isinstance(obj, str):
+            if len(obj) > head_chars:
+                return obj[:head_chars] + "...[truncated]"
+            return obj
+        if isinstance(obj, dict):
+            return {k: _shrink(v) for k, v in obj.items()}
+        if isinstance(obj, list):
+            return [_shrink(v) for v in obj]
+        return obj
+
+    try:
+        return json.dumps(_shrink(parsed), ensure_ascii=False)
+    except Exception:
+        return args
+
+
+def _summarize_tool_result(tool_name: str, tool_args: str, tool_content: str) -> str:
+    try:
+        args = json.loads(tool_args) if tool_args else {}
+    except (json.JSONDecodeError, TypeError):
+        args = {}
+
+    content = tool_content or ""
+    content_len = len(content)
+    line_count = content.count("\n") + 1 if content.strip() else 0
+
+    if tool_name == "terminal":
+        cmd = args.get("command", "")
+        if len(cmd) > 60:
+            cmd = cmd[:57] + "..."
+        exit_match = re.search(r'"exit_code"\s*:\s*(-?\d+)', content)
+        exit_code = exit_match.group(1) if exit_match else "?"
+        return f"[terminal] ran `{cmd}` -> exit {exit_code}, {line_count} lines output"
+
+    if tool_name == "read_file":
+        path = args.get("path", "?")
+        return f"[read_file] read {path} ({content_len:,} chars)"
+
+    if tool_name == "write_file":
+        path = args.get("path", "?")
+        written_lines = args.get("content", "").count("\n") + 1 if args.get("content") else "?"
+        return f"[write_file] wrote to {path} ({written_lines} lines)"
+
+    if tool_name == "patch":
+        path = args.get("path", "?")
+        return f"[patch] patched {path} ({content_len:,} chars result)"
+
+    if tool_name == "web_search":
+        query = args.get("query", "?")
+        return f"[web_search] query='{query}' ({content_len:,} chars result)"
+
+    return f"[{tool_name}] executed ({content_len:,} chars result)"
+
+
+class ContextCompressor:
+    def __init__(
+        self,
+        protect_first_n: int = 3,
+        protect_last_n: int = 8,
+    ) -> None:
+        self.protect_first_n = protect_first_n
+        self.protect_last_n = protect_last_n
+        self._previous_summary: str | None = None
+
+    def prune_old_tool_results(self, messages: list[dict[str, Any]], protect_tail_count: int) -> list[dict[str, Any]]:
+        if not messages:
+            return messages
+
+        flat = flatten_messages_for_compress(messages)
+        result = [dict(m) for m in flat]
+        prune_boundary = len(result) - protect_tail_count
+        if prune_boundary <= 0:
+            return messages
+
+        call_id_to_tool: dict[str, tuple[str, str]] = {}
+        for msg in result:
+            if msg.get("role") == "assistant":
+                for tc in msg.get("tool_calls") or []:
+                    if isinstance(tc, dict):
+                        cid = str(tc.get("id", ""))
+                        fn = tc.get("function", {})
+                        call_id_to_tool[cid] = (fn.get("name", "unknown"), fn.get("arguments", ""))
+
+        seen_hashes: set[str] = set()
+        for i in range(prune_boundary):
+            msg = result[i]
+            role = msg.get("role")
+
+            if role == "tool":
+                content = msg.get("content", "")
+                if isinstance(content, str) and len(content) > 150:
+                    digest = hashlib.md5(content.encode("utf-8")).hexdigest()
+                    if digest in seen_hashes:
+                        result[i] = {**msg, "content": "[Duplicate tool output omitted]"}
+                    else:
+                        seen_hashes.add(digest)
+                        call_id = str(msg.get("tool_call_id", ""))
+                        t_name, t_args = call_id_to_tool.get(call_id, ("unknown", ""))
+                        result[i] = {**msg, "content": _summarize_tool_result(t_name, t_args, content)}
+
+            elif role == "assistant" and msg.get("tool_calls"):
+                new_tcs = []
+                for tc in msg["tool_calls"]:
+                    if isinstance(tc, dict):
+                        args = tc.get("function", {}).get("arguments", "")
+                        if len(args) > 300:
+                            tc = {
+                                **tc,
+                                "function": {
+                                    **tc["function"],
+                                    "arguments": _truncate_tool_call_args_json(args),
+                                },
+                            }
+                    new_tcs.append(tc)
+                result[i] = {**msg, "tool_calls": new_tcs}
+
+        if messages and isinstance(messages[0].get("content"), list):
+            return messages_to_strands(result)
+        return result
+
+    async def compress(
+        self,
+        messages: list[dict[str, Any]],
+        llm_provider: Any,
+        model: str,
+        memory_manager: Any = None,
+        session_id: str = "",
+    ) -> list[dict[str, Any]]:
+        """Compress middle turns using LLM. Caller decides when to invoke."""
+        strands_input = bool(messages) and isinstance(messages[0].get("content"), list)
+        working = flatten_messages_for_compress(messages)
+        pruned_messages = self.prune_old_tool_results(working, self.protect_last_n)
+
+        head_count = min(self.protect_first_n, len(pruned_messages))
+        tail_count = min(self.protect_last_n, len(pruned_messages) - head_count)
+        middle_count = len(pruned_messages) - head_count - tail_count
+        if middle_count <= 2:
+            return messages_to_strands(pruned_messages) if strands_input else pruned_messages
+
+        head = pruned_messages[:head_count]
+        middle = pruned_messages[head_count : head_count + middle_count]
+        tail = pruned_messages[head_count + middle_count :]
+
+        middle_prompt = (
+            "You are a context compression assistant. Analyze the dialogue sequence below and extract two things:\n"
+            "1. A compact dialogue summary of the middle turns for immediate context continuation.\n"
+            "2. Key long-term facts, preferences, user habits, and general workflows that should be saved in the agent's long-term memory.\n\n"
+            "Mark each prior user task as COMPLETED unless the latest user message explicitly continues it.\n"
+            "The latest user message defines the ONLY active task — do not carry forward unfinished work from older turns.\n\n"
+            "Format your output exactly like this:\n"
+            "[CONSOLIDATION SUMMARY]\n"
+            "<compact summary of dialogue sequence>\n"
+            "[LONG-TERM FACTS]\n"
+            "<extracted long-term facts and workflows>\n\n"
+            "Conversation history to compact:\n"
+        )
+        if self._previous_summary:
+            middle_prompt += f"Previous compaction summary:\n{self._previous_summary}\n\n"
+
+        for m in middle:
+            role = m.get("role", "")
+            content = m.get("content") or ""
+            tcs = m.get("tool_calls")
+            middle_prompt += f"[{role}]: {content}\n"
+            if tcs:
+                middle_prompt += f"Tool Calls: {json.dumps(tcs)}\n"
+
+        try:
+            summary_result = await llm_provider.chat(
+                messages=[{"role": "user", "content": middle_prompt}],
+                tools=[],
+                model=model,
+            )
+            content = summary_result.content
+            if "[LONG-TERM FACTS]" in content:
+                parts = content.split("[LONG-TERM FACTS]")
+                summary_content = parts[0].replace("[CONSOLIDATION SUMMARY]", "").strip()
+                facts_part = parts[1].strip()
+            else:
+                summary_content = content.replace("[CONSOLIDATION SUMMARY]", "").strip()
+                facts_part = ""
+
+            self._previous_summary = summary_content
+            if facts_part and memory_manager and session_id:
+                await memory_manager.save_memory(session_id, facts_part)
+        except Exception:
+            LOGGER.exception("Failed to generate compaction summary")
+            summary_content = "[Compacted due to token limit: summary generation failed]"
+
+        summary_message = {
+            "role": "system",
+            "content": f"{SUMMARY_PREFIX}\n\n## Compacted Summary\n{summary_content}",
+        }
+        compressed = [*head, summary_message, *tail]
+        return messages_to_strands(compressed) if strands_input else compressed

dojoagents/agent/context_length.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import re
+
+_MAX_CONTEXT_RE = re.compile(r"maximum context length is (\d+)", re.IGNORECASE)
+_REQUESTED_TOKENS_RE = re.compile(r"requested (\d+) tokens", re.IGNORECASE)
+
+
+class ContextLengthExceededError(Exception):
+    def __init__(
+        self,
+        message: str,
+        *,
+        max_context: int | None = None,
+        requested_tokens: int | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.max_context = max_context
+        self.requested_tokens = requested_tokens
+
+
+def parse_context_length_error(message: str) -> tuple[int | None, int | None]:
+    max_match = _MAX_CONTEXT_RE.search(message)
+    req_match = _REQUESTED_TOKENS_RE.search(message)
+    max_context = int(max_match.group(1)) if max_match else None
+    requested = int(req_match.group(1)) if req_match else None
+    return max_context, requested

dojoagents/agent/dashboard_tool_protocol.py

@@ -0,0 +1,117 @@
+"""Precise dashboard tool calling guidelines injected into the agent system prompt."""
+
+from __future__ import annotations
+
+DASHBOARD_TOOL_PROTOCOL = """
+## Dashboard Tool Calling Protocol (MANDATORY)
+
+Pick the workflow by user intent. Do NOT default to search_company_ticker or web_search for stock picking.
+
+### Multi-turn sessions (CRITICAL — avoid intent drift)
+
+Each user message is a **new, independent task**. Prior turns are closed context.
+
+- If the **latest message** asks to **analyze / 分析 / 解读 / 怎么样** an existing portfolio or its candidates:
+  use read + financial tools only (`portfolio_read_search`, `portfolio_read_detail`, `get_ticker_financials`, …).
+  **Do NOT** call `portfolio_write_create`, batch add candidates, or `portfolio_eval_submit`.
+- If the **latest message** asks to **create / 创建 / 选股 / 建组合**:
+  use the portfolio build workflow below.
+- Never resume a prior turn's unfinished create/build work unless the **current message** explicitly asks.
+
+When session history mentions an old portfolio task, treat it as **already done** unless the user repeats that request now.
+
+### Task routing (choose ONE path per message)
+
+| User intent | Required tools (in order) | Do NOT use |
+|-------------|---------------------------|------------|
+| Theme / concept / industry basket (具身智能, 机器人, 半导体, AI…) | `search_sector_taxonomy` → `filter_sector_constituents` (per market) → optional `get_ticker_financials` batch → portfolio writes | `search_company_ticker`, `web_search` as primary discovery |
+| Sector analysis / compare industries | `get_taxonomy_tree` or `search_sector_taxonomy` → `get_sector_analysis` | Guessing sector ids |
+| Full-market screen (市值/PE/涨跌幅 filters, no specific sector) | `screen_market_stocks` per market → optional `get_ticker_financials` | `filter_sector_constituents` without taxonomy match |
+| Resolve one company name → ticker | `search_company_ticker` (single q, known name) | Repeated keyword searches |
+| Analyze existing portfolio / 候选池成分分析 | `portfolio_read_search` → `portfolio_read_detail` → `get_ticker_financials` batch → answer | `portfolio_write_create`, add candidates, eval_submit |
+| Single stock deep dive | `get_ticker_realtime_quote`, `get_ticker_financials`, `get_ticker_price_trends` | — |
+
+### Analyze portfolio candidates (分析候选池 / 成分股怎么样)
+
+Read-only workflow — no portfolio writes:
+
+1. `portfolio_read_search` with portfolio name from the user
+2. `portfolio_read_detail` for candidates list
+3. Batch `get_ticker_financials` (and optional quotes) on candidate tickers
+4. Summarize quality, valuation, risks — **stop**. No create, no eval_submit.
+
+### Theme / concept stock picking (e.g. 具身智能, 高息, 半导体)
+
+Concept names are NOT tickers. `search_company_ticker("具身智能")` or `search_company_ticker("Tesla")` will NOT return a complete universe.
+
+**Required workflow:**
+
+1. `search_sector_taxonomy` with the user's concept and close synonyms
+   (e.g. 具身智能 → also try 机器人, 自动化, robotics, industrial automation).
+2. From matches, pick the best L3 sector (`best_match` or highest `match_score`).
+3. For each target market (`us`, `cn`, `hk`), call `filter_sector_constituents`
+   with `sector_path_id` or the three ids from step 2 — do NOT pass sector names.
+4. Apply numeric filters on the result set:
+   - market cap: use `min_market_cap` in `screen_market_stocks` only if you pivoted to market-wide screen;
+     otherwise filter constituent rows by `market_cap` field.
+   - profitability: batch `get_ticker_financials` on candidate tickers, keep net_profit > 0.
+5. Portfolio watchlist (选股/候选池): `portfolio_write_create` → `portfolio_write_add_candidates` →
+   `portfolio_read_detail` (read `eval_summary.candidate_count`) → `portfolio_eval_submit` with **min_candidate_count**.
+
+**Eval rules (avoid retry loops):**
+- `min_candidates_by_market` must come from `portfolio_read_detail.eval_summary`, NOT from pre-filter estimates.
+- Do NOT invent per-market minimums (e.g. US≥40) unless the user explicitly asked for a count.
+- If `add_result.skipped_duplicates` is non-empty, those tickers did NOT increase the count — pick new symbols.
+- After eval failure: fix only the gap; do NOT re-print the full portfolio report.
+
+**Optional:** `get_sector_analysis` on the chosen path for sector-level context before picking names.
+
+### Portfolio: candidates vs positions (CRITICAL)
+
+| Concept | UI label | Meaning | Tool | Eval field |
+|---------|----------|---------|------|------------|
+| Watchlist | 候选股 | Track symbols, no capital spent | `portfolio_write_add_candidate(s)` | `min_candidate_count` |
+| Filled buy | 持仓 / 建仓 | Spend capital at price × qty | `portfolio_write_create_order(s)` | `min_position_count` |
+
+**User says 建仓 / 买入 / 按成本价 / 创建交易 / 持仓页面截图 with shares & cost:**
+1. `portfolio_read_search` or `portfolio_read_list` → target portfolio_id
+2. For each row: `portfolio_write_create_order` (or batch `portfolio_write_create_orders`)
+   with `order_side=buy`, `price`=cost/limit, `qty`=shares, optional `order_time`=open date
+3. `portfolio_read_detail` → verify `eval_summary.position_count` (NOT candidate_count)
+4. `portfolio_eval_submit` with **min_position_count** matching filled positions
+
+**FORBIDDEN for 建仓:** `portfolio_write_add_candidate`, `portfolio_write_add_holding`, `portfolio_write_add_holdings`
+(these only add 候选股; they never buy or set cost).
+
+**Theme basket without 建仓:** use add_candidates only — positions stay 0 until user asks to buy.
+
+### Sector taxonomy ids
+
+1. `search_sector_taxonomy` with the user's concept (synonyms auto-expanded: 具身智能 → 机器人, robotics…).
+2. Copy `sector_path_id` OR `level1_id` + `level2_id` + `level3_id` verbatim from `best_match` — exact ID lookup, no guessing.
+3. `filter_sector_constituents` with those ids + `market` + `scope: "L3"`.
+4. `get_sector_analysis` with the same ids when sector-level stats are needed.
+
+### search_company_ticker — ONLY for single-name resolution
+
+Use when the user names ONE company or ticker (Apple, 茅台, 0700.HK).
+FORBIDDEN as stock-universe builder:
+- thematic keywords (具身智能, 机器人, embodied AI)
+- looping famous names (NVIDIA, Tesla, BYD) to assemble a concept basket
+- replacing `filter_sector_constituents` or `screen_market_stocks`
+
+### web_search — supplementary only
+
+Use for news/macro context AFTER dashboard tools return candidates.
+FORBIDDEN as the primary way to discover investable tickers when sector/screen tools exist.
+
+### Portfolio tools
+
+**Watchlist / 候选股:** create → add_candidates → read_detail → eval_submit (min_candidate_count)
+**建仓 / 买入:** read_search → create_order(s) with price+qty → read_detail → eval_submit (min_position_count)
+**Delete:** read_list → write_delete → done (no read_detail, no eval_submit)
+
+### Batch calls
+
+- `get_ticker_realtime_quote` / `get_ticker_financials`: pass all tickers in one `tickers` array (≤50).
+""".strip()