gangtise-openapi-cli 0.26.0 → 0.28.0

package/dist/src/core/args.js

@@ -62,6 +62,23 @@ export function collectKeyValue(value, previous = {}) {
 export function maybeArray(value) {
     return value.length > 0 ? value : undefined;
 }
+/** True when `latest` is strictly newer than `current` (numeric per-segment
+ * compare). Plain inequality would nag "update available" during the
+ * just-published window while the registry still serves the previous version. */
+export function isVersionNewer(latest, current) {
+    const parse = (v) => v.split(".").map(Number);
+    const a = parse(latest);
+    const b = parse(current);
+    if (a.some(Number.isNaN) || b.some(Number.isNaN))
+        return false;
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const x = a[i] ?? 0;
+        const y = b[i] ?? 0;
+        if (x !== y)
+            return x > y;
+    }
+    return false;
+}
 // Whitelist for enum-valued repeatable options. Only used where the server was
 // probed NOT to reject bad values (it silently ignores the filter or returns
 // empty instead) — endpoints that answer 100003 keep server-side validation.
@@ -73,38 +90,154 @@ export function parseChoiceList(values, optionName, allowed) {
     }
     return maybeArray(values);
 }
+const YYYY_MM_DD = /^\d{4}-\d{2}-\d{2}$/;
+/**
+ * Strict `YYYY-MM-DD` guard for Quote/Fundamental date options.
+ *
+ * Beyond the documented shape the server accepts two extra year-last formats
+ * whose day/month order is *opposite* to each other (probed 2026-07-20 on
+ * quote/kline/daily and fundamental/balance-sheet; other groups sharing these
+ * flags were not probed, so the guard is applied uniformly as the safe default):
+ *
+ *   "07/01/2026" -> 2026-01-07   slash  reads DD/MM/YYYY
+ *   "07-01-2026" -> 2026-07-01   hyphen reads MM-DD-YYYY
+ *
+ * Same three digits, six months apart, both HTTP 200, and nothing in the
+ * response echoes which date the server actually used. Confirmed by the
+ * complement: "25/12/2026" parses while "12/25/2026" errors, and the hyphen
+ * forms behave exactly the other way round. Since the CLI cannot know which
+ * reading was meant, it forwards only the unambiguous form.
+ *
+ * Other unambiguous shapes (`20260701`, `2026/07/01`) are rejected too, even
+ * though the server handles them — one accepted form beats a per-shape allowlist
+ * that has to be re-probed per endpoint group. The message says which form is
+ * wanted rather than claiming the input itself was ambiguous.
+ *
+ * Datetime options (`--start-time`) are guarded separately: pass-through ones by
+ * `parseDatetimeOption` (a timezone-free field check that returns the string as-is),
+ * and the two conversion endpoints (A-share announcement / knowledge-batch) by
+ * `parseTimestamp13`.
+ */
+export function parseDateOption(value, optionName) {
+    if (!YYYY_MM_DD.test(value)) {
+        throw new ValidationError(`Invalid ${optionName}: expected YYYY-MM-DD, got "${value}" — only that form is forwarded; some endpoints silently misread other layouts (e.g. "07/01/2026") as a different day`);
+    }
+    // Shape alone lets 2026-02-30 / 2026-13-01 through; round-trip to reject those.
+    // Built from the ISO string, not Date.UTC(y,...), whose two-digit-year mapping
+    // would turn a valid year 0050 into 1950 and report it as a non-existent date.
+    const [year, month, day] = value.split("-").map(Number);
+    const parsed = new Date(`${value}T00:00:00Z`);
+    if (parsed.getUTCFullYear() !== year || parsed.getUTCMonth() !== month - 1 || parsed.getUTCDate() !== day) {
+        throw new ValidationError(`Invalid ${optionName}: "${value}" is not a real calendar date`);
+    }
+    return value;
+}
+/** Commander argParser factory — `.option("--start-date <date>", desc, dateArg("--start-date"))`. */
+export function dateArg(optionName) {
+    return (value) => parseDateOption(value, optionName);
+}
+/** `yyyy-MM-dd` with an optional ` HH:mm[:ss]` / `THH:mm[:ss]` tail. Anything else
+ * is rejected rather than handed to `new Date()`: V8's fallback parser accepts the
+ * same year-last shapes the server does but reads them the OTHER way round —
+ * `07/01/2026` is July 1 to V8 and January 7 to the server, `25/12/2026` is invalid
+ * to V8 and valid to the server (both probed 2026-07-20). Since `announcement list`
+ * converts locally while its HK/US siblings pass the string through, an open
+ * fallback made the same flag mean two dates six months apart across sibling
+ * commands, silently and with exit 0. */
+const LOCAL_DATETIME = /^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2})(?::(\d{2}))?)?$/;
+/** Field-level datetime validation, timezone-free — a real calendar day plus a
+ * valid clock time, judged by arithmetic alone (no Date construction, so no
+ * dependence on the client's timezone or DST). This is what the pass-through guard
+ * needs: a string the CLI forwards verbatim must be judged on its fields, not on
+ * whether the local zone happens to contain that wall-clock instant. */
+function datetimeFieldsValid(value) {
+    const parts = LOCAL_DATETIME.exec(value);
+    if (!parts)
+        return false;
+    const [, y, mo, d, hh = "0", mi = "0", ss = "0"] = parts;
+    const year = Number(y), month = Number(mo), day = Number(d);
+    if (month < 1 || month > 12)
+        return false;
+    const leap = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+    const dim = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1];
+    if (day < 1 || day > dim)
+        return false;
+    return Number(hh) <= 23 && Number(mi) <= 59 && Number(ss) <= 59;
+}
+/** A 10-digit seconds or 13-digit millis epoch, normalized to millis. Judged by
+ * digit count, NOT magnitude: a `> 1e12` test sends a real 13-digit `1000000000000`
+ * (which equals 1e12) down the seconds branch, and lets Number() coerce scientific
+ * / hex / whitespace-padded / 11–12–14-digit inputs through as a "timestamp" — all
+ * of which then convert wrong or get rejected by the server. Exactly 10 or 13
+ * digits, nothing else. */
+function epochMillis(value) {
+    if (/^\d{13}$/.test(value))
+        return Number(value);
+    if (/^\d{10}$/.test(value))
+        return Number(value) * 1000;
+    return undefined;
+}
 export function toTimestamp13(value) {
     if (value === undefined)
         return undefined;
-    const num = Number(value);
-    if (!Number.isNaN(num) && num > 1e12)
-        return num;
-    if (!Number.isNaN(num) && num > 1e9)
-        return num * 1000;
-    // `new Date("yyyy-MM-dd")` parses as UTC midnight while `new Date("yyyy-MM-dd HH:mm:ss")`
-    // parses as local time — for CST users the two forms would differ by 8 hours and
-    // silently shift the query window. Anchor date-only input to local midnight so both
-    // forms mean the same wall-clock day.
-    const dateOnly = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
-    if (dateOnly) {
-        const d = new Date(Number(dateOnly[1]), Number(dateOnly[2]) - 1, Number(dateOnly[3]));
-        const valid = d.getMonth() === Number(dateOnly[2]) - 1 && d.getDate() === Number(dateOnly[3]);
-        return valid ? d.getTime() : undefined;
-    }
-    const ms = new Date(value).getTime();
-    if (Number.isNaN(ms))
+    const ts = epochMillis(value);
+    if (ts !== undefined)
+        return ts;
+    if (!datetimeFieldsValid(value))
         return undefined;
-    return ms;
+    // `new Date("yyyy-MM-dd")` parses as UTC midnight while `new Date("yyyy-MM-dd
+    // HH:mm:ss")` parses as local time — for CST users the two forms would differ by 8
+    // hours. Build from local components so both mean the same wall-clock day.
+    const parts = LOCAL_DATETIME.exec(value);
+    const [, y, mo, d, hh = "0", mi = "0", ss = "0"] = parts;
+    const year = Number(y);
+    const dt = new Date(year, Number(mo) - 1, Number(d), Number(hh), Number(mi), Number(ss));
+    // Full round-trip on every field: rejects the two inputs that cannot convert
+    // faithfully — the two-digit-year remap (new Date(50,…) → 1950) and a DST gap (a
+    // wall-clock time the local zone skips: 02:30 on a US spring-forward morning, or
+    // 02:15 in Lord Howe's 30-minute gap, which only a minute-level check catches).
+    const faithful = dt.getFullYear() === year && dt.getMonth() === Number(mo) - 1
+        && dt.getDate() === Number(d) && dt.getHours() === Number(hh)
+        && dt.getMinutes() === Number(mi) && dt.getSeconds() === Number(ss);
+    return faithful ? dt.getTime() : undefined;
 }
 export function parseTimestamp13(value, optionName) {
     if (value === undefined)
         return undefined;
     const parsed = toTimestamp13(value);
     if (parsed === undefined) {
-        throw new ValidationError(`Invalid ${optionName}: expected a Unix timestamp or date string`);
+        throw new ValidationError(`Invalid ${optionName}: expected a Unix timestamp or "YYYY-MM-DD" optionally with " HH:mm[:ss]" (space or T separator), got "${value}" — year-last forms are refused because Node and the API read their day/month order the opposite way round`);
     }
     return parsed;
 }
+/**
+ * Guard for datetime options forwarded to the server AS A STRING (never converted
+ * to a timestamp): the pass-through Insight/Vault list endpoints echo the string
+ * verbatim, and probing 2026-07-21 showed they misread year-last separators exactly
+ * like the date endpoints — `insight research list` read `07/01/2026` as 2026-01-07
+ * but `07-01-2026` as 2026-07-01, a half-year apart, both HTTP 200 with nothing in
+ * the response flagging it. Accept a finite epoch or a well-formed `YYYY-MM-DD
+ * [ HH:mm[:ss]]` and return the ORIGINAL string unchanged.
+ *
+ * Validated with `datetimeFieldsValid`, NOT `toTimestamp13`: the latter's local Date
+ * round-trip would reject a DST-gap string (e.g. `2026-03-08 02:30:00` under
+ * America/New_York) that the server accepts — the CLI forwards this string as-is and
+ * the server resolves it in its own zone, so the client's timezone must not decide
+ * validity. Distinct from `parseTimestamp13`, which DOES convert (A-share
+ * announcement / knowledge-batch want epoch millis, where an unrepresentable local
+ * instant genuinely cannot convert).
+ */
+export function parseDatetimeOption(value, optionName) {
+    if (epochMillis(value) === undefined && !datetimeFieldsValid(value)) {
+        throw new ValidationError(`Invalid ${optionName}: expected a Unix timestamp or "YYYY-MM-DD" optionally with " HH:mm[:ss]" (space or T separator), got "${value}" — year-last forms are refused because the API reads their day/month order differently per separator`);
+    }
+    return value;
+}
+/** Commander argParser factory for pass-through datetime options — same role as
+ * `dateArg`, but allows an optional time part and keeps the string as-is. */
+export function datetimeArg(optionName) {
+    return (value) => parseDatetimeOption(value, optionName);
+}
 /** Machine-local calendar date as `yyyy-MM-dd`, for CLI "default: today" options.
  * `new Date().toISOString().slice(0,10)` renders the UTC day — for CST users a
  * pre-08:00 "today" resolves to yesterday. Anchoring to local components matches

package/dist/src/core/asyncContent.js

@@ -1,5 +1,6 @@
 import { ApiError } from "./errors.js";
 import { printData } from "./printer.js";
+import { isTransientError } from "./transport.js";
 // 14 attempts with exponential backoff (5s→30s cap) ≈ 316s total wait budget.
 export const POLL_MAX_ATTEMPTS = 14;
 const POLL_INITIAL_DELAY_MS = 5_000;
@@ -9,8 +10,35 @@ function nextDelayMs(attempt) {
     const grown = POLL_INITIAL_DELAY_MS * 1.6 ** (attempt - 1);
     return Math.min(POLL_MAX_DELAY_MS, Math.round(grown));
 }
+// Probed 2026-07-20 against a real viewpoint-debate job: the async endpoints are
+// still entirely on the legacy codes — 410110 "正在生成中" and 410111 "生成失败",
+// both string-typed, both HTTP 400, neither carrying the new `errorType` field.
+// The 2026-07-17 spec renumbers them to 140001 RESULT_GENERATING (409) and
+// 140002 PROCESSING_FAILED (500); those are listed ahead of the switchover
+// because the failure mode is expensive and silent — a `--wait` that does not
+// recognize the pending code aborts the poll on a job already billed 50 credits.
+const PENDING_CODES = new Set(["410110", "140001"]);
+const FAILED_CODES = new Set(["410111", "140002"]);
 function isAsyncPending(error) {
-    return error instanceof ApiError && error.code === "410110";
+    return error instanceof ApiError && error.code !== undefined && PENDING_CODES.has(error.code);
+}
+function isAsyncFailed(error) {
+    return error instanceof ApiError && error.code !== undefined && FAILED_CODES.has(error.code);
+}
+/** Terminal failures are swallowed here rather than rethrown, so this line is the
+ * user's only record of them — it has to carry what the global handler in cli.ts
+ * would have printed (code, msg, traceId). Without the traceId the failure is
+ * unreportable to Gangtise support, and README promises every error line has one. */
+function terminalFailureLine(error) {
+    const api = error instanceof ApiError ? error : undefined;
+    const code = api?.code ? ` ${api.code}` : "";
+    const trace = api?.traceId ? ` [trace ${api.traceId}]` : "";
+    const detail = api?.message ? `: ${api.message}` : "";
+    // Name the *submit* endpoint explicitly: re-running a `*-check` is a free
+    // lookup, it is resubmitting the generation job that re-bills 50 credits for a
+    // verdict that will not change (probed 2026-07-20 on sensitive content).
+    return `Content generation failed (terminal${code})${trace}${detail}\n`
+        + "This dataId is final — re-checking it will not change. Resubmitting the generation task bills again for the same result; change the parameters first.\n";
 }
 export async function pollAsyncContent(client, getContentEndpoint, dataId, format, output) {
     for (let attempt = 1; attempt <= POLL_MAX_ATTEMPTS; attempt++) {
@@ -22,12 +50,20 @@ export async function pollAsyncContent(client, getContentEndpoint, dataId, forma
             }
         }
         catch (error) {
-            if (error instanceof ApiError && error.code === "410111") {
-                process.stderr.write("Content generation failed (terminal). Do not retry.\n");
+            if (isAsyncFailed(error)) {
+                process.stderr.write(terminalFailureLine(error));
                 return "failed";
             }
-            if (!isAsyncPending(error))
-                throw error;
+            if (!isAsyncPending(error)) {
+                // AI generation windows are exactly when the server is busiest: one 5xx
+                // (after the client's own retries) must not void minutes of waiting —
+                // the dataId is still valid. Transient errors consume this attempt and
+                // polling continues; anything else (no credits, bad params) aborts.
+                if (!isTransientError(error))
+                    throw error;
+                const msg = error instanceof Error ? error.message : String(error);
+                process.stderr.write(`Attempt ${attempt}/${POLL_MAX_ATTEMPTS}: transient error (${msg.slice(0, 80)}), continuing to wait...\n`);
+            }
         }
         if (attempt < POLL_MAX_ATTEMPTS) {
             const delay = nextDelayMs(attempt);
@@ -46,8 +82,8 @@ export async function checkAsyncContent(client, getContentEndpoint, dataId, form
         }
     }
     catch (error) {
-        if (error instanceof ApiError && error.code === "410111") {
-            process.stderr.write("Content generation failed (terminal). Do not retry.\n");
+        if (isAsyncFailed(error)) {
+            process.stderr.write(terminalFailureLine(error));
             process.exitCode = 1;
             return;
         }

package/dist/src/core/client.js

@@ -4,14 +4,20 @@ import path from "node:path";
 import { pipeline } from "node:stream/promises";
 import { request } from "undici";
 import { isTokenCacheValid, normalizeToken, readTokenCache, requireAccessCredentials, writeTokenCache } from "./auth.js";
-import { ApiError, ValidationError } from "./errors.js";
+import { ApiError, attachEnvelopeTraceId, ValidationError } from "./errors.js";
 import { ENDPOINTS, resolveTimeoutMs } from "./endpoints.js";
 import { getLookupData } from "./lookupData/index.js";
 import { decodeResponseBody, getDispatcher, isVerbose, logTiming, markRetryable, PAGE_CONCURRENCY, parseRetryAfterMs, runWithConcurrency, withRetry } from "./transport.js";
-// Auth errors that warrant a forced re-login + one replay. 8000014/8000015 are
-// AK/SK errors; 0000001008 is a server-side token invalidation (the token still
-// looks valid by local expiry, so only a forced refresh recovers it).
-const AUTH_RETRY_CODES = new Set(["8000014", "8000015", "0000001008"]);
+// Auth errors that warrant a forced re-login + one replay: the token was rejected
+// server-side while still looking valid by local expiry, so only a forced refresh
+// recovers it. 0000001008 is the legacy code (probed 2026-07-20: still what the
+// token filter emits); 999002 TOKEN_INVALID is its 2026-07-17 replacement, listed
+// ahead of the rollout so self-heal does not silently die when the filter switches.
+// 8000014/8000015 are the retired AK/SK codes, kept for older server builds.
+// 999011 CREDENTIAL_INVALID is not here and could not act if it were — it comes from
+// auth.login, which runs useAuth=false and so never reaches this check. Its "never
+// replay" guarantee lives in transport's TERMINAL_API_CODES instead.
+const AUTH_RETRY_CODES = new Set(["8000014", "8000015", "0000001008", "999002"]);
 export class GangtiseClient {
     config;
     refreshPromise = null;
@@ -126,17 +132,20 @@ export class GangtiseClient {
         }
         throw new ApiError(`API request failed (HTTP ${statusCode})`, undefined, statusCode, parsed, retryAfterMs);
     }
-    unwrapEnvelope(parsed, statusCode) {
+    unwrapEnvelope(parsed, statusCode, retryAfterMs) {
         if (!this.isEnvelope(parsed)) {
             return parsed;
         }
         const code = parsed.code === undefined ? undefined : String(parsed.code);
         const ok = parsed.status === true || parsed.success === true || code === "000000" || code === "0";
         if (!ok) {
-            throw new ApiError(parsed.msg || "API request failed", code, statusCode, parsed);
+            throw new ApiError(parsed.msg || "API request failed", code, statusCode, parsed, retryAfterMs);
         }
         if ('data' in parsed) {
-            return parsed.data;
+            // Carry the envelope's traceId onto the payload: the EDE endpoints wrap a
+            // second envelope inside `data` and raise their own failures from it, by
+            // which point this is the only traceId in reach.
+            return attachEnvelopeTraceId(parsed.data, parsed.traceId);
         }
         return parsed;
     }
@@ -175,8 +184,14 @@ export class GangtiseClient {
             from: startFrom,
             size: firstPageSize,
         });
-        if (!this.isPaginatedListResponse(firstPage))
+        if (!this.isPaginatedListResponse(firstPage)) {
+            // Shape drift (e.g. total arriving as a string) silently degrades fetch-all
+            // to a single page with no partial marker — make it visible on verbose.
+            if (isVerbose()) {
+                process.stderr.write(`[gangtise] warning: ${endpoint.key} is marked paginated but the first page has an unexpected shape (no numeric total + list); returning it as-is\n`);
+            }
             return firstPage;
+        }
         const total = firstPage.total;
         const collected = [...firstPage.list];
         const available = Math.max(total - startFrom, 0);
@@ -391,20 +406,28 @@ export class GangtiseClient {
                 if (response.statusCode >= 400) {
                     this.throwHttpError(parsed, response.statusCode, retryAfterMs);
                 }
-                return this.unwrapEnvelope(parsed, response.statusCode);
+                return this.unwrapEnvelope(parsed, response.statusCode, retryAfterMs);
             }
             catch (error) {
                 await this.refreshAuthIfRecoverable(error, useAuth, authState, usedAuthorization);
                 throw error;
             }
         }, {
-            policy: endpoint.retry === "no-replay" ? "no-replay" : "default",
+            policy: endpoint.retry ?? "default",
             onRetry: (attempt, error, delay) => {
                 if (!isVerbose())
                     return;
                 const msg = error instanceof Error ? error.message : String(error);
                 process.stderr.write(`[gangtise] retry ${attempt} after ${delay.toFixed(0)}ms: ${msg.slice(0, 120)}\n`);
             },
+        }).catch((error) => {
+            // EDE uses 999999 for "no data for this query" (probed 2026-07-11) — the
+            // generic "系统错误，请稍后重试" hint would send the user retrying a query
+            // that will never have data. Swap in a context-specific hint.
+            if (endpoint.retry === 'no-999999' && error instanceof ApiError && error.code === '999999') {
+                throw new ApiError(error.message, error.code, error.statusCode, error.details, error.retryAfterMs, 'EDE 的 999999 多为查询无数据（节假日 / 未来日期 / 未覆盖标的）——先检查查询条件，确认应有数据再重试。');
+            }
+            throw error;
         });
     }
     async download(endpoint, query, options) {
@@ -477,7 +500,7 @@ export class GangtiseClient {
                     if (response.statusCode >= 400) {
                         this.throwHttpError(parsed, response.statusCode, retryAfterMs);
                     }
-                    data = this.unwrapEnvelope(parsed, response.statusCode);
+                    data = this.unwrapEnvelope(parsed, response.statusCode, retryAfterMs);
                 }
                 catch (error) {
                     await this.refreshAuthIfRecoverable(error, true, authState, authorization);
@@ -544,6 +567,9 @@ export class GangtiseClient {
                 filename,
             };
         }, {
+            // Download endpoints carry per-篇 billing too (summary/foreign-report/
+            // my-conference at 50/篇) — honor the endpoint's retry policy here as well.
+            policy: endpoint.retry ?? "default",
             onRetry: (attempt, error, delay) => {
                 if (!isVerbose())
                     return;

package/dist/src/core/download.js

@@ -18,10 +18,12 @@ function truncateFilename(name, maxBytes = 200) {
     if (Buffer.byteLength(name, "utf8") <= maxBytes)
         return name;
     const ext = extname(name);
-    let stem = name.slice(0, name.length - ext.length);
-    while (stem.length > 1 && Buffer.byteLength(stem + ext, "utf8") > maxBytes)
-        stem = stem.slice(0, -1);
-    return stem + ext;
+    // Trim by code point, not UTF-16 unit: a cut inside a surrogate pair would put
+    // a lone surrogate in the name, which reaches the filesystem as U+FFFD (�).
+    const stem = [...name.slice(0, name.length - ext.length)];
+    while (stem.length > 1 && Buffer.byteLength(stem.join("") + ext, "utf8") > maxBytes)
+        stem.pop();
+    return stem.join("") + ext;
 }
 /** Pick a non-existing path by suffixing -1, -2, … before the extension, so batch
  * downloads whose titles collide ("2025年第一季度报告" from several companies) don't
@@ -137,6 +139,11 @@ async function downloadUrlTo(url, outputPath) {
             method: "GET",
             headersTimeout: timeoutMs,
             bodyTimeout: timeoutMs,
+            // headers/body timeouts are IDLE timeouts — a stream trickling one byte
+            // per interval resets them forever. A generous total deadline (10× the
+            // per-request timeout) bounds the whole transfer without killing large
+            // legitimate downloads.
+            signal: AbortSignal.timeout(timeoutMs * 10),
             dispatcher: getDispatcher(),
         };
         let currentUrl = url;
@@ -171,7 +178,14 @@ async function downloadUrlTo(url, outputPath) {
         }
         logTiming(`GET ${redactUrl(currentUrl)}`, Date.now() - startedAt, String(response.statusCode));
     });
-    await fs.rename(partPath, outputPath);
+    try {
+        await fs.rename(partPath, outputPath);
+    }
+    catch (error) {
+        // e.g. outputPath turned out to be a directory — don't leave the .part behind.
+        await fs.unlink(partPath).catch(() => { });
+        throw error;
+    }
 }
 export async function saveDownloadResult(result, fallbackName, output) {
     if (!(result && typeof result === "object")) {

package/dist/src/core/endpoints.js

@@ -46,6 +46,8 @@ const ENDPOINT_DEFS = {
         path: "/application/open-insight/summary/v2/download/file",
         kind: "download",
         description: "Download summary file",
+        // 50/篇 — same price tier as the AI Agent calls; billing probed non-idempotent.
+        retry: "no-replay",
     },
     "insight.roadshow.list": {
         method: "POST",
@@ -100,6 +102,7 @@ const ENDPOINT_DEFS = {
         path: "/application/open-insight/foreign-report/download/file",
         kind: "download",
         description: "Download foreign report",
+        retry: "no-replay",
     },
     "insight.announcement.list": {
         method: "POST",
@@ -538,6 +541,7 @@ const ENDPOINT_DEFS = {
         path: "/application/open-vault/my-conference/download/file",
         kind: "download",
         description: "Download my conference resource",
+        retry: "no-replay",
     },
     "vault.wechat-message.list": {
         method: "POST",
@@ -599,18 +603,21 @@ const ENDPOINT_DEFS = {
         path: "/application/open-indicator/EDE/search",
         kind: "json",
         description: "Search data indicators by keyword (returns indicatorCode + params)",
+        retry: "no-999999",
     },
     "indicator.cross-section": {
         method: "POST",
         path: "/application/open-indicator/EDE/cross-section",
         kind: "json",
         description: "Get cross-section data (multi-indicator x multi-security, single date)",
+        retry: "no-999999",
     },
     "indicator.time-series": {
         method: "POST",
         path: "/application/open-indicator/EDE/time-series",
         kind: "json",
         description: "Get time-series data (multi-indicator x single-security OR single-indicator x multi-security)",
+        retry: "no-999999",
     },
 };
 export const ENDPOINTS = Object.fromEntries(Object.entries(ENDPOINT_DEFS).map(([key, def]) => [key, { key, ...def }]));