opencandle 0.12.0 → 0.13.0

package/dist/gui/server/history-snapshot-store.js

@@ -0,0 +1,43 @@
+export class HistorySnapshotStore {
+    maxAgeMs;
+    now;
+    entries = new Map();
+    constructor(maxAgeMs = 60_000, now = Date.now) {
+        this.maxAgeMs = maxAgeMs;
+        this.now = now;
+    }
+    get(key, build) {
+        const existing = this.entries.get(key);
+        if (existing?.hasValue && this.now() - existing.fetchedAtMs < this.maxAgeMs) {
+            return Promise.resolve(existing.value);
+        }
+        if (existing?.inFlight)
+            return existing.inFlight;
+        const entry = existing ??
+            { hasValue: false, fetchedAtMs: 0, inFlight: null };
+        let buildPromise;
+        try {
+            buildPromise = build();
+        }
+        catch (error) {
+            buildPromise = Promise.reject(error);
+        }
+        const inFlight = buildPromise
+            .then((value) => {
+            entry.value = value;
+            entry.hasValue = true;
+            entry.fetchedAtMs = this.now();
+            return value;
+        })
+            .finally(() => {
+            if (entry.inFlight === inFlight)
+                entry.inFlight = null;
+        });
+        entry.inFlight = inFlight;
+        this.entries.set(key, entry);
+        return inFlight;
+    }
+    clear() {
+        this.entries.clear();
+    }
+}

package/dist/gui/server/http-routes.d.ts

@@ -2,6 +2,7 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { type AgentSession, SessionManager } from "@earendil-works/pi-coding-agent";
 import type { ToolInvokeController } from "./invoke-tool.js";
 import type { LocalSessionCoordinator, SessionActionEnvelope } from "./local-session-coordinator.js";
+import type { MarketIndicesSnapshotStore } from "./market-indices-snapshot-store.js";
 import { type ModelSetupController } from "./model-setup.js";
 import type { QuoteSnapshotStore } from "./quote-snapshot-store.js";
 import { type SessionActionsController } from "./session-actions.js";
@@ -29,6 +30,7 @@ interface GuiHttpRouteOptions {
     sessionActionsController: SessionActionsController;
     toolInvokeController: ToolInvokeController;
     quoteSnapshotStore: QuoteSnapshotStore;
+    indicesSnapshotStore: MarketIndicesSnapshotStore;
     localSessionCoordinator?: LocalSessionCoordinator;
 }
 export interface ChatRunImageInput {

package/dist/gui/server/http-routes.js

@@ -1,6 +1,6 @@
 import { createReadStream, existsSync } from "node:fs";
 import { extname, join, resolve } from "node:path";
-import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { ModelRegistry, SessionManager } from "@earendil-works/pi-coding-agent";
 import { buildDoctorReport } from "../../doctor/report.js";
 import { MarketStateService } from "../../market-state/service.js";
 import { formatLatestReportSummary, formatPortfolioSummary, formatWatchlistSummary, } from "../../market-state/summaries.js";
@@ -9,7 +9,7 @@ import { probeProviderStatus } from "../../onboarding/provider-status.js";
 import { clearPendingSessionAction, hasAcceptedSessionAction, hasPendingSessionAction, recordAcceptedSessionAction, recordPendingSessionAction, } from "../../pi/session-action-dedupe.js";
 import { sessionEntriesToChatEvents } from "./chat-event-adapter.js";
 import { createLiveChatEventAdapter } from "./live-chat-event-adapter.js";
-import { buildMarketStateSnapshot, getInstrumentQuoteSnapshot, getSavedMarketStateSymbols, searchInstrumentCandidates, } from "./market-state-api.js";
+import { buildMarketStateSnapshot, getInstrumentHistorySnapshot, getInstrumentOverviewSnapshot, getInstrumentQuoteSnapshot, getSavedMarketStateSymbols, searchInstrumentCandidates, } from "./market-state-api.js";
 import { buildModelSetupState } from "./model-setup.js";
 import { isTrustedPrivateApiRequest, privateApiCookieHeader } from "./private-api-access.js";
 import { projectDashboard } from "./projector.js";
@@ -84,9 +84,10 @@ export function createHttpRequestHandler(options) {
         if (url.pathname === "/api/model-setup/refresh" && req.method === "POST") {
             if (!allowTrustedGuiRequest(req, res, "Model setup API", options))
                 return;
-            options.getSession().modelRegistry.refresh();
-            options.wsHub.broadcastModelSetup();
-            writeJson(res, await options.wsHub.buildBootstrapPayload());
+            await handleTrustedGuiMutation(req, res, options, async () => {
+                await options.getSession().modelRuntime.refresh();
+                options.wsHub.broadcastModelSetup();
+            });
             return;
         }
         if (url.pathname === "/api/model-setup/api-key" && req.method === "POST") {
@@ -128,6 +129,12 @@ export function createHttpRequestHandler(options) {
             writeJson(res, await options.quoteSnapshotStore.get());
             return;
         }
+        if (url.pathname === "/api/market-state/indices" && req.method === "GET") {
+            if (!allowTrustedGuiRequest(req, res, "Market-state API", options))
+                return;
+            writeJson(res, await options.indicesSnapshotStore.get());
+            return;
+        }
         if (url.pathname === "/api/doctor" && req.method === "GET") {
             if (!allowTrustedGuiRequest(req, res, "Diagnostics API", options))
                 return;
@@ -143,7 +150,7 @@ export function createHttpRequestHandler(options) {
                     reachable: true,
                     healthEndpoint: `http://${options.host}:${options.port}/health`,
                 },
-                modelSetup: buildModelSetupState(session.modelRegistry, session.model),
+                modelSetup: buildModelSetupState(new ModelRegistry(session.modelRuntime), session.model),
             }));
             return;
         }
@@ -159,6 +166,23 @@ export function createHttpRequestHandler(options) {
             writeJson(res, await getInstrumentQuoteSnapshot(url.searchParams.get("symbol") ?? ""));
             return;
         }
+        if (url.pathname === "/api/instruments/overview" && req.method === "GET") {
+            if (!allowTrustedGuiRequest(req, res, "Market-state API", options))
+                return;
+            writeJson(res, await getInstrumentOverviewSnapshot(url.searchParams.get("symbol") ?? ""));
+            return;
+        }
+        if (url.pathname === "/api/instruments/history" && req.method === "GET") {
+            if (!allowTrustedGuiRequest(req, res, "Market-state API", options))
+                return;
+            const snapshot = await getInstrumentHistorySnapshot(url.searchParams.get("symbol") ?? "", url.searchParams.get("range") ?? "1D", url.searchParams.get("interval") ?? undefined);
+            if (snapshot.status === "invalid_request") {
+                writeJson(res, snapshot, 400);
+                return;
+            }
+            writeJson(res, snapshot);
+            return;
+        }
         if (url.pathname === "/api/diagnostics/twitter-cli" && req.method === "GET") {
             if (!allowTrustedGuiRequest(req, res, "Diagnostics API", options))
                 return;
@@ -529,6 +553,7 @@ async function streamAcceptedSseChatRun({ res, options, activeRunSessionIds, tar
         startSeq: seq,
         emit: (event) => writeSse(res, event),
         originalPrompt: prompt,
+        dispatchedPrompt,
         originalAttachments: inputAttachmentLabels,
     });
     const observation = createPromptObservation();
@@ -563,7 +588,7 @@ async function streamAcceptedSseChatRun({ res, options, activeRunSessionIds, tar
     });
     try {
         recordPendingSessionAction(runSessionManager, actionId);
-        const modelSetup = buildModelSetupState(runSession.modelRegistry, runSession.model);
+        const modelSetup = buildModelSetupState(new ModelRegistry(runSession.modelRuntime), runSession.model);
         if (!prompt.startsWith("/") && modelSetup.requirement !== "ready") {
             runSessionManager.appendMessage({ role: "user", content: prompt, timestamp: Date.now() });
             recordAcceptedAction();

package/dist/gui/server/live-chat-event-adapter.d.ts

@@ -10,6 +10,8 @@ export interface LiveChatEventAdapterOptions {
      * message with an expanded prompt; the live view renders this instead.
      */
     originalPrompt?: string;
+    /** Prompt sent to Pi before any workflow input transform. */
+    dispatchedPrompt?: string;
     originalAttachments?: MessageAttachmentChip[];
 }
 export interface LiveChatEventAdapter {

package/dist/gui/server/live-chat-event-adapter.js

@@ -42,21 +42,39 @@ export function createLiveChatEventAdapter(options) {
                     const message = event.message;
                     if (message.role === "user") {
                         const messageId = `${options.runId}-user-${++userCount}`;
-                        const text = userCount === 1 && options.originalPrompt
-                            ? options.originalPrompt
-                            : messageText(message.content);
-                        emit({ type: "message.created", runId: options.runId, messageId, role: "user" });
-                        emit({
-                            type: "message.completed",
-                            runId: options.runId,
-                            messageId,
-                            content: userMessageContent(message.content, text),
-                            ...(userCount === 1 &&
-                                options.originalAttachments &&
-                                options.originalAttachments.length > 0
-                                ? { attachments: options.originalAttachments }
-                                : {}),
-                        });
+                        const promptText = messageText(message.content);
+                        const text = userCount === 1 && options.originalPrompt ? options.originalPrompt : promptText;
+                        const transformedFirstPrompt = userCount === 1 &&
+                            options.dispatchedPrompt !== undefined &&
+                            promptText.trim() !== options.dispatchedPrompt.trim();
+                        const workflowStep = transformedFirstPrompt || userCount > 1;
+                        if (userCount === 1 || !workflowStep) {
+                            emit({ type: "message.created", runId: options.runId, messageId, role: "user" });
+                            emit({
+                                type: "message.completed",
+                                runId: options.runId,
+                                messageId,
+                                content: userMessageContent(message.content, text),
+                                ...(userCount === 1 &&
+                                    options.originalAttachments &&
+                                    options.originalAttachments.length > 0
+                                    ? { attachments: options.originalAttachments }
+                                    : {}),
+                            });
+                        }
+                        if (workflowStep) {
+                            emit({
+                                type: "custom.message",
+                                messageId: `${options.runId}-workflow-step-${userCount}`,
+                                customType: "opencandle-workflow-step",
+                                content: [{ type: "text", text: promptText }],
+                                details: {
+                                    label: "Workflow step",
+                                    stage: "workflow",
+                                    step: userCount,
+                                },
+                            });
+                        }
                         return;
                     }
                     if (message.role === "assistant") {

package/dist/gui/server/market-indices-api.d.ts

@@ -0,0 +1,21 @@
+import { type MarketSparklineSnapshot } from "./market-state-api.js";
+export declare const MARKET_INDEX_SYMBOLS: readonly ["^GSPC", "^IXIC", "^DJI", "BTC-USD"];
+export interface MarketIndexSnapshotEntry {
+    symbol: (typeof MARKET_INDEX_SYMBOLS)[number];
+    name?: string;
+    status: "ok" | "unavailable";
+    reason?: string;
+    price?: number;
+    change?: number;
+    changePercent?: number;
+    currency?: string | null;
+    marketState?: "PRE" | "REGULAR" | "POST" | "CLOSED";
+    dataAsOf?: string;
+    stale?: boolean;
+    sparkline?: MarketSparklineSnapshot;
+}
+export interface MarketIndicesSnapshot {
+    generatedAt: string;
+    indices: MarketIndexSnapshotEntry[];
+}
+export declare function buildMarketIndicesSnapshot(): Promise<MarketIndicesSnapshot>;

package/dist/gui/server/market-indices-api.js

@@ -0,0 +1,26 @@
+import { fetchQuoteSnapshot, fetchSparklineSnapshot, } from "./market-state-api.js";
+export const MARKET_INDEX_SYMBOLS = ["^GSPC", "^IXIC", "^DJI", "BTC-USD"];
+export async function buildMarketIndicesSnapshot() {
+    const indices = [];
+    for (const symbol of MARKET_INDEX_SYMBOLS) {
+        const quote = await fetchQuoteSnapshot(symbol);
+        if (quote.status === "unavailable") {
+            indices.push({ symbol, status: "unavailable", reason: quote.reason });
+            continue;
+        }
+        indices.push({
+            symbol,
+            name: quote.name,
+            status: "ok",
+            price: quote.price,
+            change: quote.change,
+            changePercent: quote.changePercent,
+            currency: quote.currency,
+            marketState: quote.marketState,
+            dataAsOf: quote.dataAsOf,
+            stale: quote.stale,
+            sparkline: await fetchSparklineSnapshot(symbol),
+        });
+    }
+    return { generatedAt: new Date().toISOString(), indices };
+}

package/dist/gui/server/market-indices-snapshot-store.d.ts

@@ -0,0 +1,12 @@
+import type { MarketIndicesSnapshot } from "./market-indices-api.js";
+export declare class MarketIndicesSnapshotStore {
+    private readonly build;
+    private readonly maxAgeMs;
+    private readonly now;
+    private snapshot;
+    private fetchedAtMs;
+    private inFlight;
+    constructor(build: () => Promise<MarketIndicesSnapshot>, maxAgeMs?: number, now?: () => number);
+    get(): Promise<MarketIndicesSnapshot>;
+    private refresh;
+}

package/dist/gui/server/market-indices-snapshot-store.js

@@ -0,0 +1,56 @@
+export class MarketIndicesSnapshotStore {
+    build;
+    maxAgeMs;
+    now;
+    snapshot = null;
+    fetchedAtMs = 0;
+    inFlight = null;
+    constructor(build, maxAgeMs = 60_000, now = Date.now) {
+        this.build = build;
+        this.maxAgeMs = maxAgeMs;
+        this.now = now;
+    }
+    async get() {
+        if (this.snapshot == null)
+            return this.refresh();
+        if (this.now() - this.fetchedAtMs >= this.maxAgeMs) {
+            this.refresh().catch(() => { });
+            return {
+                ...this.snapshot,
+                indices: this.snapshot.indices.map((entry) => ({ ...entry, stale: true })),
+            };
+        }
+        return this.snapshot;
+    }
+    refresh() {
+        if (this.inFlight)
+            return this.inFlight;
+        const inFlight = this.build()
+            .then((snapshot) => {
+            if (this.snapshot && snapshot.indices.some((entry) => entry.status === "unavailable")) {
+                const validRefreshCount = snapshot.indices.filter((entry) => entry.status === "ok").length;
+                if (validRefreshCount === 0)
+                    return this.snapshot;
+                const priorBySymbol = new Map(this.snapshot.indices.map((entry) => [entry.symbol, entry]));
+                snapshot = {
+                    ...snapshot,
+                    indices: snapshot.indices.map((entry) => {
+                        if (entry.status === "ok")
+                            return entry;
+                        const prior = priorBySymbol.get(entry.symbol);
+                        return prior?.status === "ok" ? { ...prior, stale: true } : entry;
+                    }),
+                };
+            }
+            this.snapshot = snapshot;
+            this.fetchedAtMs = this.now();
+            return snapshot;
+        })
+            .finally(() => {
+            if (this.inFlight === inFlight)
+                this.inFlight = null;
+        });
+        this.inFlight = inFlight;
+        return inFlight;
+    }
+}

package/dist/gui/server/market-state-api.d.ts

@@ -1,6 +1,62 @@
 import type Database from "better-sqlite3";
 import { searchYahooInstruments } from "../../market-state/resolve.js";
 import { MarketStateService } from "../../market-state/service.js";
+import { HISTORY_INTERVALS, type HISTORY_RANGES } from "../../tools/market/stock-history.js";
+type HistoryRange = (typeof HISTORY_RANGES)[number];
+type HistoryInterval = (typeof HISTORY_INTERVALS)[number];
+export interface ResolvedHistoryRange {
+    range: HistoryRange;
+    interval: HistoryInterval;
+}
+export interface InvalidHistoryRequest {
+    status: "invalid_request";
+    reason: string;
+}
+export interface InstrumentHistoryBar {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+export interface InstrumentHistorySnapshotOk {
+    status: "ok";
+    symbol: string;
+    range: string;
+    interval: HistoryInterval;
+    source: InstrumentHistorySource;
+    fetchedAt: string;
+    dataAsOf?: string;
+    stale: boolean;
+    prevClose: number | null;
+    bars: InstrumentHistoryBar[];
+}
+export interface InstrumentHistorySnapshotUnavailable {
+    status: "unavailable";
+    reason: string;
+    dataAsOf?: string;
+    stale?: boolean;
+}
+export type InstrumentHistorySnapshot = InstrumentHistorySnapshotOk | InstrumentHistorySnapshotUnavailable | InvalidHistoryRequest;
+type InstrumentHistorySource = "Yahoo Finance" | "Alpha Vantage" | "London Strategic Edge";
+export declare function resolveHistoryRange(rangeLabel: string, intervalOverride?: string): ResolvedHistoryRange | InvalidHistoryRequest;
+export declare function getInstrumentHistorySnapshot(symbol: string, rangeLabel?: string, intervalOverride?: string): Promise<InstrumentHistorySnapshot>;
+export declare function resetInstrumentHistoryMemoForTests(): void;
+export type MarketSparklineSnapshot = {
+    status: "ok";
+    source: "Yahoo Finance";
+    points: number[];
+    fetchedAt: string;
+    dataAsOf?: string;
+    stale: false;
+} | {
+    status: "unavailable";
+    source: "Yahoo Finance";
+    reason: string;
+    dataAsOf?: string;
+    stale?: boolean;
+};
 export interface MarketStateSnapshot {
     instruments: Array<NonNullable<ReturnType<MarketStateService["getInstrument"]>>>;
     watchlists: ReturnType<MarketStateService["listWatchlists"]>;
@@ -42,6 +98,7 @@ export interface MarketStateQuoteSnapshot {
         extendedAsOf?: string;
         stale?: boolean;
         reason?: string;
+        sparkline: MarketSparklineSnapshot;
     }>;
     portfolioQuotes: Array<{
         lotId: number;
@@ -68,6 +125,7 @@ export interface MarketStateQuoteSnapshot {
         extendedAsOf?: string;
         stale?: boolean;
         reason?: string;
+        sparkline: MarketSparklineSnapshot;
     }>;
     portfolioSummary: {
         portfolioId: number;
@@ -104,6 +162,7 @@ export declare function createSavedSymbolsMemo(load: () => string[], options?: S
 export declare const getSavedMarketStateSymbols: () => string[];
 export declare function buildMarketStateSnapshot(db?: Database.Database): MarketStateSnapshot;
 export declare function buildMarketStateQuoteSnapshot(db?: Database.Database): Promise<MarketStateQuoteSnapshot>;
+export declare function fetchSparklineSnapshot(symbol: string): Promise<MarketSparklineSnapshot>;
 export declare function searchInstrumentCandidates(query: string): Promise<{
     query: string;
     candidates: Awaited<ReturnType<typeof searchYahooInstruments>>;
@@ -121,6 +180,7 @@ export declare function getInstrumentQuoteSnapshot(symbol: string): Promise<{
     low: number;
     week52High: number;
     week52Low: number;
+    marketCap: number;
     fetchedAt: string;
     dataAsOf?: string;
     marketState?: "PRE" | "REGULAR" | "POST" | "CLOSED";
@@ -135,4 +195,56 @@ export declare function getInstrumentQuoteSnapshot(symbol: string): Promise<{
     status: "unavailable";
     reason: string;
 }>;
+export type InstrumentOverviewSnapshot = {
+    symbol: string;
+    status: "ok";
+    name: string;
+    description: string;
+    exchange: string;
+    sector: string;
+    industry: string;
+    marketCap: number;
+    pe: number | null;
+    forwardPe: number | null;
+    eps: number | null;
+    dividendYield: number | null;
+    beta: number | null;
+    avgVolume: number;
+    profitMargin: number | null;
+    revenueGrowth: number | null;
+    week52High: number;
+    week52Low: number;
+    stale: boolean;
+} | {
+    symbol: string;
+    status: "unavailable";
+    reason: string;
+};
+export declare function getInstrumentOverviewSnapshot(symbol: string): Promise<InstrumentOverviewSnapshot>;
+export declare function resetInstrumentOverviewMemoForTests(): void;
+export declare function fetchQuoteSnapshot(symbol: string): Promise<{
+    status: "ok";
+    name?: string;
+    price: number;
+    change: number;
+    changePercent: number;
+    volume: number;
+    high: number;
+    low: number;
+    week52High: number;
+    week52Low: number;
+    marketCap: number;
+    fetchedAt: string;
+    dataAsOf?: string;
+    marketState?: "PRE" | "REGULAR" | "POST" | "CLOSED";
+    extendedPrice?: number;
+    extendedChange?: number;
+    extendedChangePercent?: number;
+    extendedAsOf?: string;
+    stale: boolean;
+    currency: string | null;
+} | {
+    status: "unavailable";
+    reason: string;
+}>;
 export {};