opencandle 0.4.0 → 0.6.0

package/gui/server/invoke-tool.ts

@@ -5,6 +5,8 @@ import type { TSchema } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 import { getDefaults } from "../../src/memory/tool-defaults.js";
 import { wrapWithDefaults } from "../../src/runtime/tool-defaults-wrapper.js";
+import { getAllTools } from "../../src/tools/index.js";
+import { buildToolInvokeAckMessage } from "./tool-invoke-ack.js";
 
 export interface InvokeToolResult {
   toolCallId: string;
@@ -12,6 +14,81 @@ export interface InvokeToolResult {
   isError: boolean;
 }
 
+interface ToolInvokeClient {
+  send(message: unknown): void;
+}
+
+export interface ToolInvokeController {
+  handleToolInvoke(toolName: string, args: Record<string, unknown>): Promise<InvokeToolResult>;
+  handleToolInvokeMessage(client: ToolInvokeClient, data: Record<string, unknown>): Promise<void>;
+}
+
+export interface ToolInvokeControllerOptions {
+  role: string;
+  getSessionManager: () => SessionManager;
+  broadcastState: () => void;
+  onMarketStateChanged?: () => void;
+  getTools?: typeof getAllTools;
+  invokeTool?: typeof invokeToolFromUi;
+}
+
+export function createToolInvokeController({
+  role,
+  getSessionManager,
+  broadcastState,
+  onMarketStateChanged,
+  getTools = getAllTools,
+  invokeTool = invokeToolFromUi,
+}: ToolInvokeControllerOptions): ToolInvokeController {
+  async function handleToolInvoke(
+    toolName: string,
+    args: Record<string, unknown>,
+  ): Promise<InvokeToolResult> {
+    if (role !== "writer") throw new Error("Read-only follower mode");
+    const tool = getTools().find((candidate) => candidate.name === toolName);
+    if (!tool) throw new Error(`Unknown tool: ${toolName}`);
+    const result = await invokeTool(getSessionManager(), tool, args, "ui");
+    if (!result.isError && marketStateToolMapping(toolName) != null) {
+      onMarketStateChanged?.();
+    }
+    broadcastState();
+    return result;
+  }
+
+  async function handleToolInvokeMessage(
+    client: ToolInvokeClient,
+    data: Record<string, unknown>,
+  ): Promise<void> {
+    const requestId = typeof data.requestId === "string" ? data.requestId : "";
+    const toolName = String(data.toolName ?? "");
+    try {
+      const result = await handleToolInvoke(toolName, requestArgs(data.args));
+      if (requestId) {
+        client.send(buildToolInvokeAckMessage(requestId, toolName, result));
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (requestId) {
+        client.send({
+          type: "tool.invoke.result",
+          requestId,
+          ok: false,
+          toolName,
+          error: { message },
+        });
+        return;
+      }
+      throw error;
+    }
+  }
+
+  return { handleToolInvoke, handleToolInvokeMessage };
+}
+
+function requestArgs(value: unknown): Record<string, unknown> {
+  return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : {};
+}
+
 export async function invokeToolFromUi(
   sessionManager: SessionManager,
   tool: AgentTool<TSchema, unknown>,
@@ -68,7 +145,12 @@ export async function invokeToolFromUi(
       toolCallId,
       toolName: tool.name,
       content: result.content,
-      details: { source, args, value: result.details },
+      details: {
+        source,
+        args,
+        value: result.details,
+        ...stateChangeDetails(tool.name, args, result.details, source),
+      },
       isError,
       timestamp: Date.now(),
     });
@@ -77,6 +159,67 @@ export async function invokeToolFromUi(
   return { toolCallId, result, isError };
 }
 
+function stateChangeDetails(
+  toolName: string,
+  args: Record<string, unknown>,
+  value: unknown,
+  source: "ui" | "background",
+): { stateChange: Record<string, unknown> } | Record<string, never> {
+  const mapping = marketStateToolMapping(toolName);
+  if (mapping == null) return {};
+
+  const valueRecord = asRecord(value);
+  return {
+    stateChange: {
+      source,
+      domain: mapping.domain,
+      action: typeof args.action === "string" ? args.action : "invoke",
+      targetType: mapping.targetType,
+      targetId: numericField(valueRecord, "id"),
+      targetIds: numericArrayField(valueRecord, "removedLotIds"),
+      instrumentId: numericField(valueRecord, "instrumentId"),
+      instrumentIds: numericArrayField(valueRecord, "instrumentIds"),
+      toolName,
+    },
+  };
+}
+
+function marketStateToolMapping(toolName: string): { domain: string; targetType: string } | null {
+  switch (toolName) {
+    case "manage_watchlist":
+      return { domain: "watchlist", targetType: "watchlist_item" };
+    case "track_portfolio":
+      return { domain: "portfolio", targetType: "portfolio_lot" };
+    case "track_prediction":
+      return { domain: "predictions", targetType: "prediction" };
+    case "manage_alerts":
+      return { domain: "alerts", targetType: "alert_rule" };
+    case "daily_watchlist_report":
+      return { domain: "reports", targetType: "report_run" };
+    default:
+      return null;
+  }
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : null;
+}
+
+function numericField(record: Record<string, unknown> | null, key: string): number | undefined {
+  const value = record?.[key];
+  return typeof value === "number" ? value : undefined;
+}
+
+function numericArrayField(
+  record: Record<string, unknown> | null,
+  key: string,
+): number[] | undefined {
+  const value = record?.[key];
+  if (!Array.isArray(value)) return undefined;
+  const numbers = value.filter((item): item is number => typeof item === "number");
+  return numbers.length > 0 ? numbers : undefined;
+}
+
 function emptyUsage(): Usage {
   return {
     input: 0,

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

@@ -1,5 +1,5 @@
-import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 import type { AssistantMessage, Message } from "@earendil-works/pi-ai";
+import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 import type { ChatEvent, MessageContent, ToolOutput } from "../shared/chat-events.js";
 
 export interface LiveChatEventAdapterOptions {
@@ -7,6 +7,11 @@ export interface LiveChatEventAdapterOptions {
   sessionId: string;
   startSeq: number;
   emit: (event: ChatEvent) => void;
+  /**
+   * The user's words as typed. Workflow transforms can replace the first user
+   * message with an expanded prompt; the live view renders this instead.
+   */
+  originalPrompt?: string;
 }
 
 export interface LiveChatEventAdapter {
@@ -14,7 +19,9 @@ export interface LiveChatEventAdapter {
   nextSeq(): number;
 }
 
-export function createLiveChatEventAdapter(options: LiveChatEventAdapterOptions): LiveChatEventAdapter {
+export function createLiveChatEventAdapter(
+  options: LiveChatEventAdapterOptions,
+): LiveChatEventAdapter {
   let seq = options.startSeq;
   let userCount = 0;
   let assistantCount = 0;
@@ -55,11 +62,15 @@ export function createLiveChatEventAdapter(options: LiveChatEventAdapterOptions)
           const message = event.message as 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", messageId, role: "user" });
             emit({
               type: "message.completed",
               messageId,
-              content: [{ type: "text", text: messageText(message.content) }],
+              content: [{ type: "text", text }],
             });
             return;
           }
@@ -161,14 +172,18 @@ function messageText(content: unknown): string {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
   return content
-    .map((part) => typeof part === "object" && part !== null && "text" in part && typeof part.text === "string" ? part.text : "")
+    .map((part) =>
+      typeof part === "object" && part !== null && "text" in part && typeof part.text === "string"
+        ? part.text
+        : "",
+    )
     .join("");
 }
 
 function toolOutput(result: unknown, isError: boolean): ToolOutput {
   const record = asRecord(result);
   return {
-    content: Array.isArray(record.content) ? record.content as ToolOutput["content"] : [],
+    content: Array.isArray(record.content) ? (record.content as ToolOutput["content"]) : [],
     details: record.details,
     isError,
   };
@@ -176,6 +191,6 @@ function toolOutput(result: unknown, isError: boolean): ToolOutput {
 
 function asRecord(value: unknown): Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value)
-    ? value as Record<string, unknown>
+    ? (value as Record<string, unknown>)
     : {};
 }

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

@@ -0,0 +1,315 @@
+import type Database from "better-sqlite3";
+import { isZeroFilledQuote, searchYahooInstruments } from "../../src/market-state/resolve.js";
+import { MarketStateService } from "../../src/market-state/service.js";
+import { initDefaultDatabase } from "../../src/memory/sqlite.js";
+import { wrapProvider } from "../../src/providers/wrap-provider.js";
+import { getQuote } from "../../src/providers/yahoo-finance.js";
+
+export interface MarketStateSnapshot {
+  instruments: Array<NonNullable<ReturnType<MarketStateService["getInstrument"]>>>;
+  watchlist: ReturnType<MarketStateService["listWatchlistItems"]>;
+  portfolio: ReturnType<MarketStateService["listPortfolioLots"]>;
+  predictions: ReturnType<MarketStateService["listPredictions"]>;
+  alerts: ReturnType<MarketStateService["listAlertRules"]>;
+  alertEvents: ReturnType<MarketStateService["listAlertEvents"]>;
+  alertCheckRuns: ReturnType<MarketStateService["listAlertCheckRuns"]>;
+  reportTemplates: ReturnType<MarketStateService["listReportTemplates"]>;
+  reportRuns: ReturnType<MarketStateService["listReportRuns"]>;
+  runnerLease: ReturnType<MarketStateService["getAutomationRunnerLease"]>;
+  notifications: ReturnType<MarketStateService["listNotificationEvents"]>;
+  notificationDeliveryAttempts: ReturnType<MarketStateService["listNotificationDeliveryAttempts"]>;
+}
+
+export interface MarketStateQuoteSnapshot {
+  generatedAt: string;
+  watchlistQuotes: Array<{
+    itemId: number;
+    instrumentId: number;
+    symbol: string;
+    status: "ok" | "unavailable";
+    price?: number;
+    changePercent?: number;
+    fetchedAt?: string;
+    stale?: boolean;
+    reason?: string;
+  }>;
+  portfolioQuotes: Array<{
+    lotId: number;
+    instrumentId: number;
+    symbol: string;
+    status: "ok" | "unavailable";
+    currentPrice?: number;
+    changePercent?: number;
+    marketValue?: number;
+    totalCost: number;
+    pnl?: number;
+    pnlPercent?: number;
+    allocationPercent?: number;
+    currency: string;
+    includedInTotals: boolean;
+    fetchedAt?: string;
+    stale?: boolean;
+    reason?: string;
+  }>;
+  predictionQuotes: Array<{
+    predictionId: number;
+    instrumentId: number;
+    symbol: string;
+    status: "ok" | "unavailable";
+    currentPrice?: number;
+    changePercent?: number;
+    fetchedAt?: string;
+    stale?: boolean;
+    reason?: string;
+  }>;
+  portfolioSummary: {
+    baseCurrency: string;
+    totalValue: number;
+    totalCost: number;
+    totalPnl: number;
+    totalPnlPercent: number;
+    excludedFromTotals: Array<{ symbol: string; currency: string; reason: string }>;
+  };
+}
+
+export function buildMarketStateSnapshot(db?: Database.Database): MarketStateSnapshot {
+  const ownedDb = db ?? initDefaultDatabase();
+  const service = new MarketStateService(ownedDb);
+  try {
+    const alerts = service.listAlertRules();
+    const instrumentIds = [
+      ...new Set(alerts.map((rule) => rule.instrumentId).filter((id) => id != null)),
+    ];
+    return {
+      instruments: instrumentIds
+        .map((id) => service.getInstrument(id))
+        .filter((instrument) => instrument != null),
+      watchlist: service.listWatchlistItems(),
+      portfolio: service.listPortfolioLots(),
+      predictions: service.listPredictions(),
+      alerts,
+      alertEvents: service.listAlertEvents(),
+      alertCheckRuns: service.listAlertCheckRuns(),
+      reportTemplates: service.listReportTemplates(),
+      reportRuns: service.listReportRuns(),
+      runnerLease: service.getAutomationRunnerLease(),
+      notifications: service.listNotificationEvents(),
+      notificationDeliveryAttempts: service.listNotificationDeliveryAttempts(),
+    };
+  } finally {
+    if (!db) ownedDb.close();
+  }
+}
+
+export async function buildMarketStateQuoteSnapshot(
+  db?: Database.Database,
+): Promise<MarketStateQuoteSnapshot> {
+  const ownedDb = db ?? initDefaultDatabase();
+  const service = new MarketStateService(ownedDb);
+  try {
+    const watchlist = service.listWatchlistItems();
+    const portfolio = service.listPortfolioLots();
+    const predictions = service.listPredictions();
+    const symbols = [
+      ...new Set([
+        ...watchlist.map((item) => item.symbol),
+        ...portfolio.map((lot) => lot.symbol),
+        ...predictions.map((prediction) => prediction.symbol),
+      ]),
+    ];
+    const quoteMap = new Map<string, Awaited<ReturnType<typeof fetchQuoteSnapshot>>>();
+    for (const symbol of symbols) {
+      quoteMap.set(symbol, await fetchQuoteSnapshot(symbol));
+    }
+
+    const generatedAt = new Date().toISOString();
+    const watchlistQuotes = watchlist.map((item) => {
+      const quote = quoteMap.get(item.symbol);
+      if (quote == null || quote.status === "unavailable") {
+        return {
+          itemId: item.id,
+          instrumentId: item.instrumentId,
+          symbol: item.symbol,
+          status: "unavailable" as const,
+          reason: quote?.reason ?? "quote unavailable",
+        };
+      }
+      return {
+        itemId: item.id,
+        instrumentId: item.instrumentId,
+        symbol: item.symbol,
+        status: "ok" as const,
+        price: quote.price,
+        changePercent: quote.changePercent,
+        fetchedAt: quote.fetchedAt,
+        stale: quote.stale,
+      };
+    });
+
+    const baseCurrency = service.getDefaultPortfolio().baseCurrency ?? "USD";
+    const portfolioQuotes = portfolio.map((lot) => {
+      const quote = quoteMap.get(lot.symbol);
+      const lotCurrency = lot.currency || baseCurrency;
+      const quoteCurrency = lot.instrumentCurrency || lotCurrency;
+      const includedInTotals = lotCurrency === baseCurrency && quoteCurrency === baseCurrency;
+      const totalCost = lot.avgCost * lot.quantity;
+      if (quote == null || quote.status === "unavailable") {
+        return {
+          lotId: lot.id,
+          instrumentId: lot.instrumentId,
+          symbol: lot.symbol,
+          status: "unavailable" as const,
+          totalCost,
+          currency: lotCurrency,
+          includedInTotals: false,
+          reason: quote?.reason ?? "quote unavailable",
+        };
+      }
+      const resolvedQuoteCurrency = quote.currency ?? quoteCurrency;
+      if (resolvedQuoteCurrency !== lotCurrency) {
+        return {
+          lotId: lot.id,
+          instrumentId: lot.instrumentId,
+          symbol: lot.symbol,
+          status: "unavailable" as const,
+          currentPrice: null,
+          marketValue: null,
+          totalCost,
+          pnl: null,
+          pnlPercent: null,
+          currency: lotCurrency,
+          includedInTotals: false,
+          reason: `No FX conversion from ${resolvedQuoteCurrency} to ${lotCurrency}`,
+          fetchedAt: quote.fetchedAt,
+          stale: quote.stale,
+        };
+      }
+      const marketValue = quote.price * lot.quantity;
+      return {
+        lotId: lot.id,
+        instrumentId: lot.instrumentId,
+        symbol: lot.symbol,
+        status: "ok" as const,
+        currentPrice: quote.price,
+        changePercent: quote.changePercent,
+        marketValue,
+        totalCost,
+        pnl: marketValue - totalCost,
+        pnlPercent: totalCost > 0 ? ((marketValue - totalCost) / totalCost) * 100 : 0,
+        currency: lotCurrency,
+        includedInTotals,
+        fetchedAt: quote.fetchedAt,
+        stale: quote.stale,
+        reason: includedInTotals
+          ? undefined
+          : `No FX conversion from ${lotCurrency === baseCurrency ? quoteCurrency : lotCurrency} to ${baseCurrency}`,
+      };
+    });
+    const included = portfolioQuotes.filter(
+      (quote) => quote.status === "ok" && quote.includedInTotals,
+    );
+    const totalValue = included.reduce((sum, quote) => sum + (quote.marketValue ?? 0), 0);
+    const totalCost = included.reduce((sum, quote) => sum + quote.totalCost, 0);
+    const portfolioQuotesWithAllocation = portfolioQuotes.map((quote) => {
+      if (quote.status !== "ok" || !quote.includedInTotals || totalValue <= 0) return quote;
+      return {
+        ...quote,
+        allocationPercent: ((quote.marketValue ?? 0) / totalValue) * 100,
+      };
+    });
+    const excludedFromTotals = portfolioQuotesWithAllocation
+      .filter((quote) => quote.status !== "ok" || !quote.includedInTotals)
+      .map((quote) => ({
+        symbol: quote.symbol,
+        currency: quote.currency,
+        reason: quote.reason ?? "quote unavailable",
+      }));
+    const predictionQuotes = predictions.map((prediction) => {
+      const quote = quoteMap.get(prediction.symbol);
+      if (quote == null || quote.status === "unavailable") {
+        return {
+          predictionId: prediction.id,
+          instrumentId: prediction.instrumentId,
+          symbol: prediction.symbol,
+          status: "unavailable" as const,
+          reason: quote?.reason ?? "quote unavailable",
+        };
+      }
+      return {
+        predictionId: prediction.id,
+        instrumentId: prediction.instrumentId,
+        symbol: prediction.symbol,
+        status: "ok" as const,
+        currentPrice: quote.price,
+        changePercent: quote.changePercent,
+        fetchedAt: quote.fetchedAt,
+        stale: quote.stale,
+      };
+    });
+
+    return {
+      generatedAt,
+      watchlistQuotes,
+      portfolioQuotes: portfolioQuotesWithAllocation,
+      predictionQuotes,
+      portfolioSummary: {
+        baseCurrency,
+        totalValue,
+        totalCost,
+        totalPnl: totalValue - totalCost,
+        totalPnlPercent: totalCost > 0 ? ((totalValue - totalCost) / totalCost) * 100 : 0,
+        excludedFromTotals,
+      },
+    };
+  } finally {
+    if (!db) ownedDb.close();
+  }
+}
+
+export async function searchInstrumentCandidates(query: string): Promise<{
+  query: string;
+  candidates: Awaited<ReturnType<typeof searchYahooInstruments>>;
+  error?: string;
+}> {
+  const trimmed = query.trim();
+  if (!trimmed) return { query: "", candidates: [] };
+  try {
+    return {
+      query: trimmed,
+      candidates: await searchYahooInstruments(trimmed),
+    };
+  } catch (err) {
+    return {
+      query: trimmed,
+      candidates: [],
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+async function fetchQuoteSnapshot(symbol: string): Promise<
+  | {
+      status: "ok";
+      price: number;
+      changePercent: number;
+      fetchedAt: string;
+      stale?: boolean;
+      currency: string | null;
+    }
+  | { status: "unavailable"; reason: string }
+> {
+  const result = await wrapProvider("yahoo", () => getQuote(symbol));
+  if (result.status === "unavailable") return { status: "unavailable", reason: result.reason };
+  if (result.stale) return { status: "unavailable", reason: "provider returned stale market data" };
+  if (isZeroFilledQuote(result.data)) {
+    return { status: "unavailable", reason: "Yahoo returned no valid market data." };
+  }
+  return {
+    status: "ok",
+    price: result.data.price,
+    changePercent: result.data.changePercent,
+    fetchedAt: result.timestamp,
+    stale: result.stale,
+    currency: result.data.currency ?? null,
+  };
+}