opencandle 0.12.0 → 0.13.0

package/dist/providers/lse.js

@@ -0,0 +1,284 @@
+import { getConfig } from "../config.js";
+import { cache, STALE_LIMIT, TTL } from "../infra/cache.js";
+import { markExhausted, recordBytes } from "../infra/lse-byte-budget.js";
+import { rateLimiter } from "../infra/rate-limiter.js";
+import { ProviderCredentialError } from "./provider-credential-error.js";
+const BASE_URL = "https://api.londonstrategicedge.com/vault";
+const MAX_RETRIES = 2;
+const RETRY_DELAY_MS = 1_000;
+const MAX_RETRY_AFTER_MS = 5_000;
+export class LseHttpError extends Error {
+    status;
+    detail;
+    constructor(status, detail) {
+        super(`LSE HTTP ${status}: ${detail}`);
+        this.status = status;
+        this.detail = detail;
+        this.name = "LseHttpError";
+    }
+}
+function throwIfLseAuthError(error) {
+    if (error instanceof ProviderCredentialError && error.provider === "lse")
+        throw error;
+    if (error instanceof LseHttpError && (error.status === 401 || error.status === 403)) {
+        throw new ProviderCredentialError("lse", "stale", error.status);
+    }
+}
+async function readErrorDetail(response) {
+    try {
+        const body = (await response.json());
+        if (typeof body.detail === "string")
+            return body.detail;
+    }
+    catch {
+        // Preserve a useful typed HTTP error even when the provider body is not JSON.
+    }
+    return response.statusText || `HTTP ${response.status}`;
+}
+function parseRetryAfterMs(value) {
+    if (!value?.trim())
+        return undefined;
+    const seconds = Number(value.trim());
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return seconds * 1_000;
+    const dateMs = Date.parse(value.trim());
+    if (Number.isNaN(dateMs))
+        return undefined;
+    return Math.max(0, dateMs - Date.now());
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function lseGet(path, params) {
+    const apiKey = getConfig().lseApiKey;
+    if (!apiKey)
+        throw new ProviderCredentialError("lse", "missing");
+    const url = `${BASE_URL}${path}?${new URLSearchParams(params)}`;
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        const response = await globalThis.fetch(url, { headers: { "x-api-key": apiKey } });
+        const dataBytes = response.headers.get("x-data-bytes");
+        if (dataBytes !== null) {
+            const parsedBytes = Number(dataBytes);
+            if (Number.isFinite(parsedBytes))
+                recordBytes(parsedBytes);
+        }
+        if (response.ok)
+            return (await response.json());
+        const error = new LseHttpError(response.status, await readErrorDetail(response));
+        throwIfLseAuthError(error);
+        lastError = error;
+        if (response.status === 429 && error.detail.toLowerCase().includes("allowance")) {
+            markExhausted();
+            throw error;
+        }
+        const retryable = response.status === 429 || response.status >= 500;
+        if (!retryable || attempt === MAX_RETRIES)
+            throw error;
+        const retryAfterMs = parseRetryAfterMs(response.headers.get("retry-after"));
+        await sleep(retryAfterMs === undefined
+            ? RETRY_DELAY_MS * (attempt + 1)
+            : Math.min(retryAfterMs, MAX_RETRY_AFTER_MS));
+    }
+    throw lastError ?? new Error("LSE request failed without an error");
+}
+export async function getLseCandles(symbol, timeframe, opts = {}) {
+    const params = { symbol, timeframe };
+    if (opts.start !== undefined)
+        params.start = opts.start.slice(0, 10);
+    if (opts.end !== undefined)
+        params.end = opts.end;
+    if (opts.order !== undefined)
+        params.order = opts.order;
+    if (opts.limit !== undefined)
+        params.limit = String(opts.limit);
+    const cacheKey = `lse:candles:${new URLSearchParams(params)}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    try {
+        await rateLimiter.acquire("lse");
+        const rows = await lseGet("/candles", params);
+        if (!isValidLseCandlePayload(rows)) {
+            throw new Error("LSE candles response did not contain valid candle rows");
+        }
+        cache.set(cacheKey, rows, TTL.CANDLES);
+        return rows;
+    }
+    catch (error) {
+        throwIfLseAuthError(error);
+        const stale = cache.getStale(cacheKey, STALE_LIMIT.CANDLES);
+        if (stale)
+            return stale.value;
+        throw error;
+    }
+}
+function isValidLseCandlePayload(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((row) => {
+            if (typeof row !== "object" || row === null)
+                return false;
+            const candle = row;
+            const timestamp = typeof candle.ts === "string"
+                ? Date.parse(/(?:Z|[+-]\d{2}:\d{2})$/i.test(candle.ts) ? candle.ts : `${candle.ts}Z`)
+                : Number.NaN;
+            const prices = [candle.open, candle.high, candle.low, candle.close];
+            return (Number.isFinite(timestamp) &&
+                prices.every((price) => typeof price === "number" && Number.isFinite(price) && price > 0) &&
+                (candle.high ?? 0) >= Math.max(candle.open ?? 0, candle.close ?? 0) &&
+                (candle.low ?? Number.POSITIVE_INFINITY) <=
+                    Math.min(candle.open ?? Number.POSITIVE_INFINITY, candle.close ?? Number.POSITIVE_INFINITY) &&
+                typeof candle.volume === "number" &&
+                Number.isFinite(candle.volume) &&
+                candle.volume >= 0);
+        }));
+}
+export async function getLseFinancialReports(symbol, reportType, opts = {}) {
+    const params = { symbol, report_type: reportType };
+    if (opts.period !== undefined)
+        params.period = opts.period;
+    if (opts.start !== undefined)
+        params.start = opts.start;
+    if (opts.end !== undefined)
+        params.end = opts.end;
+    if (opts.order !== undefined)
+        params.order = opts.order;
+    if (opts.limit !== undefined)
+        params.limit = String(opts.limit);
+    const cacheKey = `lse:financial_reports:${new URLSearchParams(params)}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    try {
+        await rateLimiter.acquire("lse");
+        const rows = await lseGet("/ref/financial_reports", params);
+        cache.set(cacheKey, rows, TTL.FINANCIAL_REPORTS);
+        return rows;
+    }
+    catch (error) {
+        throwIfLseAuthError(error);
+        const stale = cache.getStale(cacheKey, STALE_LIMIT.FINANCIAL_REPORTS);
+        if (stale)
+            return stale.value;
+        throw error;
+    }
+}
+function parseNum(value) {
+    if (typeof value !== "number" && typeof value !== "string")
+        return undefined;
+    if (typeof value === "string" && value.trim() === "")
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function parseReportData(row) {
+    if (typeof row.data !== "string")
+        return undefined;
+    try {
+        const parsed = JSON.parse(row.data);
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function indexReportData(rows) {
+    const indexed = new Map();
+    for (const row of rows) {
+        if (typeof row.date !== "string")
+            continue;
+        const data = parseReportData(row);
+        if (data)
+            indexed.set(row.date, data);
+    }
+    return indexed;
+}
+export async function getLseFinancials(symbol) {
+    const [incomeRows, balanceRows, cashflowRows] = await Promise.all([
+        getLseFinancialReports(symbol, "income", { period: "FY" }),
+        getLseFinancialReports(symbol, "balance", { period: "FY" }),
+        getLseFinancialReports(symbol, "cashflow", { period: "FY" }),
+    ]);
+    const balanceByDate = indexReportData(balanceRows);
+    const cashflowByDate = indexReportData(cashflowRows);
+    const statements = incomeRows
+        .flatMap((row) => {
+        if (typeof row.date !== "string")
+            return [];
+        const income = parseReportData(row);
+        return income ? [{ date: row.date, income }] : [];
+    })
+        .sort((a, b) => b.date.localeCompare(a.date))
+        .flatMap(({ date, income }) => {
+        const balance = balanceByDate.get(date);
+        const cashflow = cashflowByDate.get(date);
+        if (!balance || !cashflow)
+            return [];
+        const revenue = parseNum(income.revenue);
+        const grossProfit = parseNum(income.grossProfit);
+        const operatingIncome = parseNum(income.operatingIncome);
+        const netIncome = parseNum(income.netIncome);
+        const eps = parseNum(income.eps);
+        const totalAssets = parseNum(balance.totalAssets);
+        const totalLiabilities = parseNum(balance.totalLiabilities);
+        const totalEquity = parseNum(balance.totalEquity);
+        const operatingCashFlow = parseNum(cashflow.operatingCashFlow);
+        const reportedFreeCashFlow = parseNum(cashflow.freeCashFlow);
+        const capitalExpenditure = parseNum(cashflow.capitalExpenditure);
+        const freeCashFlow = reportedFreeCashFlow ??
+            (operatingCashFlow !== undefined && capitalExpenditure !== undefined
+                ? // LSE capex is negative; subtract its magnitude to match AV's positive-capex semantics.
+                    operatingCashFlow - Math.abs(capitalExpenditure)
+                : undefined);
+        if (revenue === undefined ||
+            grossProfit === undefined ||
+            operatingIncome === undefined ||
+            netIncome === undefined ||
+            eps === undefined ||
+            totalAssets === undefined ||
+            totalLiabilities === undefined ||
+            totalEquity === undefined ||
+            operatingCashFlow === undefined ||
+            freeCashFlow === undefined) {
+            return [];
+        }
+        return [
+            {
+                fiscalDate: date,
+                revenue,
+                grossProfit,
+                operatingIncome,
+                netIncome,
+                eps,
+                totalAssets,
+                totalLiabilities,
+                totalEquity,
+                operatingCashFlow,
+                freeCashFlow,
+                totalDebt: parseNum(balance.totalDebt),
+                cashAndEquivalents: parseNum(balance.cashAndCashEquivalents),
+                sharesOutstanding: parseNum(income.weightedAverageShsOut),
+            },
+        ];
+    })
+        .slice(0, 4);
+    if (statements.length === 0) {
+        throw new Error(`LSE returned no complete financial statements for ${symbol}`);
+    }
+    return statements;
+}
+export function toLseTimeframe(interval) {
+    const timeframes = {
+        "1m": "1m",
+        "5m": "5m",
+        "15m": "15m",
+        "1h": "1h",
+        "1d": "1d",
+        "1wk": "1w",
+        "1mo": "1mo",
+    };
+    return timeframes[interval];
+}

package/dist/providers/polymarket.js

@@ -51,7 +51,13 @@ function marketToQuotes(market, event) {
     const liquidityUsd = numberValue(market.liquidityNum) ??
         numberValue(market.liquidity) ??
         numberValue(event?.liquidity);
-    const closeDate = stringValue(market.endDate) ?? normalizeDateOnly(market.endDateIso ?? event?.endDate);
+    const rawCloseDate = stringValue(market.endDate) ?? normalizeDateOnly(market.endDateIso ?? event?.endDate);
+    // A past close date on a market Gamma explicitly marks active is the same
+    // stale metadata isOpenMarket ignores; presenting it as a close date would
+    // tell users an open market already closed, so it is omitted instead.
+    const closeDate = rawCloseDate !== undefined && booleanValue(market.active) === true && isPastDate(rawCloseDate)
+        ? undefined
+        : rawCloseDate;
     const url = marketUrl(market, event);
     const asOf = stringValue(market.updatedAt) ?? stringValue(event?.updatedAt);
     return outcomes.flatMap((outcome, index) => {
@@ -76,15 +82,26 @@ function marketToQuotes(market, event) {
     });
 }
 function isOpenMarket(market) {
-    if (booleanValue(market.closed) === true)
+    const closed = booleanValue(market.closed);
+    const active = booleanValue(market.active);
+    if (closed === true)
         return false;
-    if (booleanValue(market.active) === false)
+    if (active === false)
         return false;
+    // An explicit affirmative active flag is Gamma's authoritative openness
+    // signal and beats the endDate heuristic, whose metadata is demonstrably
+    // stale on live markets. A lone `closed: false` only says "not settled",
+    // so it still falls through to the date check.
+    if (active === true)
+        return true;
     const endDate = stringValue(market.endDate) ?? stringValue(market.endDateIso);
     if (!endDate)
         return true;
-    const parsed = new Date(endDate);
-    return Number.isNaN(parsed.getTime()) || parsed.getTime() > Date.now();
+    return !isPastDate(endDate);
+}
+function isPastDate(value) {
+    const parsed = new Date(value);
+    return !Number.isNaN(parsed.getTime()) && parsed.getTime() <= Date.now();
 }
 function normalizeLimit(limit) {
     if (!Number.isFinite(limit))

package/dist/providers/wrap-provider.js

@@ -36,6 +36,7 @@ export async function wrapProvider(providerId, fn) {
             status: "ok",
             data,
             timestamp,
+            provider: providerId,
             cached: cache?.status === "cached" ? true : undefined,
             stale: cache?.status === "stale" ? true : undefined,
         };

package/dist/providers/yahoo-finance.js

@@ -310,6 +310,7 @@ export async function getHistory(symbol, range = "6mo", interval = "1d") {
         const ohlcv = timestamps
             .map((ts, i) => ({
             date: new Date(ts * 1000).toISOString().split("T")[0],
+            timestamp: ts,
             open: quotes.open[i],
             high: quotes.high[i],
             low: quotes.low[i],

package/dist/routing/route-manifest.js

@@ -9,6 +9,7 @@ export const TOOL_BUNDLE_TOOLS = {
         "search_ticker",
         "get_stock_quote",
         "get_stock_history",
+        "get_price_comparison",
         "screen_stocks",
         "get_crypto_price",
         "get_crypto_history",

package/dist/routing/router.js

@@ -638,6 +638,13 @@ export function postProcessRouterOutput(text, output, inputContext) {
     const selectedToolBundles = isConceptualEducationRequest(text, next)
         ? []
         : selectToolBundles(next);
+    if (isExplicitMacroDataRequest(text) && !selectedToolBundles.includes("macro")) {
+        selectedToolBundles.push("macro");
+        diagnostics.push({
+            code: "macro_tool_bundle_recovered",
+            message: "explicit macro data request retained the macro tool bundle",
+        });
+    }
     if (selectedToolBundles.length === 0 && isConceptualEducationRequest(text, next)) {
         diagnostics.push({
             code: "conceptual_education_no_tools",
@@ -659,7 +666,7 @@ export function postProcessRouterOutput(text, output, inputContext) {
     });
 }
 function isExplicitMacroDataRequest(text) {
-    return /\b(?:get_economic_data|fred|cpi|inflation|fed\s+funds?|unemployment|gdp|macro)\b/i.test(text);
+    return /\b(?:get_economic_data|fred|cpi|inflation|fed\s+funds?|unemployment|gdp|macro|fear\s*(?:&|and)\s*greed)\b/i.test(text);
 }
 function isConceptualEducationRequest(text, output) {
     if (output.routeKind !== "agent_task")

package/dist/runtime/evidence.d.ts

@@ -19,6 +19,7 @@ export interface ProviderResultOk<T> {
     status: "ok";
     data: T;
     timestamp: string;
+    provider?: string;
     cached?: boolean;
     stale?: boolean;
 }

package/dist/runtime/evidence.js

@@ -11,7 +11,7 @@ export function toEvidenceRecord(label, result, providerId) {
             provenance: {
                 source: result.stale ? "stale_cache" : "fetched",
                 timestamp: result.timestamp,
-                provider: providerId,
+                provider: providerId ?? result.provider,
                 confidence: result.stale ? 0.5 : undefined,
             },
         };

package/dist/runtime/session-coordinator.d.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, ModelRuntime, SessionEntry } from "@earendil-works/pi-coding-agent";
 import { MemoryStorage } from "../memory/index.js";
 /**
  * Alias for the session-manager handle extensions receive via
@@ -52,7 +52,7 @@ export declare class SessionCoordinator {
     /** Run setup flow. */
     runSetup(pi: ExtensionAPI, ctx: ExtensionContext | ExtensionCommandContext, options: {
         mode: "startup" | "manual";
-    }): Promise<"ready" | "shutdown" | "cancelled">;
+    }, modelRuntime?: ModelRuntime): Promise<"ready" | "shutdown" | "cancelled">;
     /** Extract and persist user preferences from natural language. */
     extractAndStorePreferences(text: string): void;
     /** Record a workflow run in storage. */

package/dist/runtime/session-coordinator.js

@@ -112,8 +112,8 @@ export class SessionCoordinator {
         this.sessionId = sessionId;
     }
     /** Run setup flow. */
-    async runSetup(pi, ctx, options) {
-        return runOpenCandleSetup(pi, ctx, options);
+    async runSetup(pi, ctx, options, modelRuntime) {
+        return runOpenCandleSetup(pi, ctx, options, modelRuntime);
     }
     /** Extract and persist user preferences from natural language. */
     extractAndStorePreferences(text) {

package/dist/tools/fundamentals/dcf.js

@@ -1,6 +1,8 @@
 import { Type } from "@sinclair/typebox";
 import { getConfig } from "../../config.js";
+import { isOverSoftThreshold } from "../../infra/lse-byte-budget.js";
 import { getFinancials, getOverview } from "../../providers/alpha-vantage.js";
+import { getLseFinancials } from "../../providers/lse.js";
 import { ProviderCredentialError } from "../../providers/provider-credential-error.js";
 import { wrapProvider } from "../../providers/wrap-provider.js";
 import { getQuote, getYahooFinancials } from "../../providers/yahoo-finance.js";
@@ -129,10 +131,33 @@ export const dcfTool = {
         const symbol = args.symbol.toUpperCase();
         const config = getConfig();
         const alphaVantageApiKey = config.alphaVantageApiKey;
-        const [alphaVantageFinancialsResult, quoteResult] = await Promise.all([
-            optionalAlphaVantage(alphaVantageApiKey, (apiKey) => getFinancials(symbol, apiKey)),
-            wrapProvider("yahoo", () => getQuote(symbol)),
-        ]);
+        const quotePromise = wrapProvider("yahoo", () => getQuote(symbol));
+        const lseEligible = !!config.lseApiKey && !isOverSoftThreshold();
+        let lseFinancialsResult;
+        if (lseEligible) {
+            try {
+                lseFinancialsResult = await wrapProvider("lse", () => getLseFinancials(symbol));
+            }
+            catch (error) {
+                if (error instanceof ProviderCredentialError) {
+                    lseFinancialsResult = {
+                        status: "unavailable",
+                        reason: `London Strategic Edge credential ${error.reason}`,
+                        provider: "lse",
+                    };
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        const lseIsFresh = lseFinancialsResult?.status === "ok" &&
+            lseFinancialsResult.data.length > 0 &&
+            !lseFinancialsResult.stale;
+        const alphaVantageFinancialsResult = lseIsFresh
+            ? undefined
+            : await optionalAlphaVantage(alphaVantageApiKey, (apiKey) => getFinancials(symbol, apiKey));
+        const quoteResult = await quotePromise;
         const missing = [];
         if (quoteResult.status === "unavailable")
             missing.push(`stock quote (${quoteResult.reason})`);
@@ -159,17 +184,21 @@ export const dcfTool = {
                 details: null,
             };
         }
-        let financialsSource = "Alpha Vantage";
+        let financialsSource = lseIsFresh ? "London Strategic Edge" : "Alpha Vantage";
         let financials;
-        if (alphaVantageFinancialsResult.status === "ok" && !alphaVantageFinancialsResult.stale) {
+        if (lseIsFresh && lseFinancialsResult?.status === "ok") {
+            financials = lseFinancialsResult.data;
+        }
+        else if (alphaVantageFinancialsResult?.status === "ok" &&
+            !alphaVantageFinancialsResult.stale) {
             financials = alphaVantageFinancialsResult.data;
         }
         else {
-            const alphaVantageReason = alphaVantageFinancialsResult.status === "ok"
+            const alphaVantageReason = alphaVantageFinancialsResult?.status === "ok"
                 ? `stale cached financial statements${alphaVantageFinancialsResult.timestamp
                     ? ` from ${alphaVantageFinancialsResult.timestamp}`
                     : ""}`
-                : alphaVantageFinancialsResult.reason;
+                : (alphaVantageFinancialsResult?.reason ?? "Alpha Vantage unavailable");
             const yahooFinancialsResult = await wrapProvider("yahoo", () => getYahooFinancials(symbol));
             if (yahooFinancialsResult.status === "unavailable") {
                 return {

package/dist/tools/fundamentals/financials.js

@@ -1,7 +1,10 @@
 import { Type } from "@sinclair/typebox";
 import { getConfig } from "../../config.js";
+import { isOverSoftThreshold } from "../../infra/lse-byte-budget.js";
 import { withCredentialCheck } from "../../onboarding/tool-helpers.js";
 import { getFinancials } from "../../providers/alpha-vantage.js";
+import { getLseFinancials } from "../../providers/lse.js";
+import { ProviderCredentialError } from "../../providers/provider-credential-error.js";
 import { wrapProvider } from "../../providers/wrap-provider.js";
 const params = Type.Object({
     symbol: Type.String({ description: "Stock ticker symbol (e.g. AAPL, MSFT)" }),
@@ -9,20 +12,18 @@ const params = Type.Object({
 export const financialsTool = {
     name: "get_financials",
     label: "Financial Statements",
-    description: "Get annual income statement data: revenue, gross profit, operating income, net income, and EPS. Requires Alpha Vantage.",
+    description: "Get annual income statement data: revenue, gross profit, operating income, net income, and EPS. Uses London Strategic Edge or Alpha Vantage.",
     parameters: params,
     async execute(_toolCallId, args) {
-        return withCredentialCheck("alpha_vantage", async () => {
-            const apiKey = getConfig().alphaVantageApiKey;
-            if (!apiKey)
-                throw new Error("Alpha Vantage credential is missing.");
-            const result = await wrapProvider("alphavantage", () => getFinancials(args.symbol.toUpperCase(), apiKey));
+        const symbol = args.symbol.toUpperCase();
+        const config = getConfig();
+        const renderResult = (result, source) => {
             if (result.status === "unavailable") {
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `⚠ Financial statements unavailable for ${args.symbol.toUpperCase()} (${result.reason}). Analysis will proceed without financials.`,
+                            text: `⚠ Financial statements unavailable for ${symbol} (${result.reason}). Analysis will proceed without financials.`,
                         },
                     ],
                     details: [],
@@ -35,10 +36,87 @@ export const financialsTool = {
                     details: [],
                 };
             }
-            const header = `${args.symbol.toUpperCase()} — Annual Income Statement (${statements.length} years)`;
+            const header = `${symbol} — Annual Income Statement (${statements.length} years)`;
             const rows = statements.map((s) => `${s.fiscalDate} | Rev: $${fmt(s.revenue)} | GP: $${fmt(s.grossProfit)} | OpInc: $${fmt(s.operatingIncome)} | Net: $${fmt(s.netIncome)}`);
-            const text = [header, ...rows].join("\n");
-            return { content: [{ type: "text", text }], details: statements };
+            const sourceLine = source ? [`Source: ${source}`] : [];
+            const staleLine = result.stale
+                ? [`Data status: stale cache from ${result.timestamp} (provider unavailable)`]
+                : [];
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: [header, ...sourceLine, ...staleLine, ...rows].join("\n"),
+                    },
+                ],
+                details: statements,
+            };
+        };
+        const runAlphaVantageOnly = () => withCredentialCheck("alpha_vantage", async () => {
+            const apiKey = getConfig().alphaVantageApiKey;
+            if (!apiKey)
+                throw new Error("Alpha Vantage credential is missing.");
+            const result = await wrapProvider("alphavantage", () => getFinancials(symbol, apiKey));
+            return renderResult(result);
+        });
+        const lseEligible = !!config.lseApiKey && !isOverSoftThreshold();
+        if (!lseEligible)
+            return runAlphaVantageOnly();
+        const lseEntry = {
+            provider: "lse",
+            fn: async () => {
+                try {
+                    const statements = await getLseFinancials(symbol);
+                    if (statements.length === 0)
+                        throw new Error("no financial statements returned");
+                    return statements;
+                }
+                catch (error) {
+                    if (error instanceof ProviderCredentialError) {
+                        throw new Error(`London Strategic Edge credential ${error.reason}`);
+                    }
+                    throw error;
+                }
+            },
+        };
+        if (!config.alphaVantageApiKey) {
+            const result = await wrapProvider(lseEntry.provider, lseEntry.fn);
+            if (result.status === "ok")
+                return renderResult(result, "London Strategic Edge");
+            return runAlphaVantageOnly();
+        }
+        return withCredentialCheck("alpha_vantage", async () => {
+            const apiKey = config.alphaVantageApiKey;
+            if (!apiKey)
+                throw new Error("Alpha Vantage credential is missing.");
+            const lseResult = await wrapProvider(lseEntry.provider, lseEntry.fn);
+            if (lseResult.status === "ok" && !lseResult.stale) {
+                return renderResult(lseResult, "London Strategic Edge");
+            }
+            let alphaVantageResult;
+            try {
+                alphaVantageResult = await wrapProvider("alphavantage", () => getFinancials(symbol, apiKey));
+            }
+            catch (error) {
+                if (error instanceof ProviderCredentialError && lseResult.status === "ok") {
+                    return renderResult(lseResult, "London Strategic Edge");
+                }
+                throw error;
+            }
+            if (alphaVantageResult.status === "ok" && !alphaVantageResult.stale) {
+                return renderResult(alphaVantageResult, "Alpha Vantage");
+            }
+            if (lseResult.status === "ok") {
+                return renderResult(lseResult, "London Strategic Edge");
+            }
+            if (alphaVantageResult.status === "ok") {
+                return renderResult(alphaVantageResult, "Alpha Vantage");
+            }
+            return renderResult({
+                status: "unavailable",
+                provider: "fallback",
+                reason: `lse: ${lseResult.reason}; alphavantage: ${alphaVantageResult.reason}`,
+            });
         });
     },
 };