opencandle 0.11.1 → 0.12.0

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

@@ -1,243 +0,0 @@
-import type { AssistantMessage, Message } from "@earendil-works/pi-ai";
-import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
-import type {
-  ChatEvent,
-  MessageAttachmentChip,
-  MessageContent,
-  ToolOutput,
-} from "../shared/chat-events.js";
-
-export interface LiveChatEventAdapterOptions {
-  runId: string;
-  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;
-  originalAttachments?: MessageAttachmentChip[];
-}
-
-export interface LiveChatEventAdapter {
-  handle(event: AgentSessionEvent): void;
-  nextSeq(): number;
-}
-
-export function createLiveChatEventAdapter(
-  options: LiveChatEventAdapterOptions,
-): LiveChatEventAdapter {
-  let seq = options.startSeq;
-  let userCount = 0;
-  let assistantCount = 0;
-  let currentAssistantMessageId: string | undefined;
-  let lastAssistantMessageId: string | undefined;
-  const completedMessageIds = new Set<string>();
-
-  const emit = (event: Omit<ChatEvent, "seq" | "sessionId">) => {
-    options.emit({ ...event, sessionId: options.sessionId, seq: seq++ } as ChatEvent);
-  };
-
-  const ensureAssistantMessage = (): string => {
-    if (currentAssistantMessageId) return currentAssistantMessageId;
-    currentAssistantMessageId = `${options.runId}-assistant-${++assistantCount}`;
-    lastAssistantMessageId = currentAssistantMessageId;
-    emit({
-      type: "message.created",
-      runId: options.runId,
-      messageId: currentAssistantMessageId,
-      role: "assistant",
-    });
-    return currentAssistantMessageId;
-  };
-
-  const messageIdForTool = (): string => lastAssistantMessageId ?? ensureAssistantMessage();
-
-  const completeAssistantMessage = (message: AssistantMessage) => {
-    const messageId = ensureAssistantMessage();
-    if (completedMessageIds.has(messageId)) return;
-    completedMessageIds.add(messageId);
-    emit({
-      type: "message.completed",
-      runId: options.runId,
-      messageId,
-      content: contentToChatContent(message.content),
-    });
-    currentAssistantMessageId = undefined;
-  };
-
-  return {
-    handle(event) {
-      switch (event.type) {
-        case "message_start": {
-          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", 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 }
-                : {}),
-            });
-            return;
-          }
-          if (message.role === "assistant") {
-            ensureAssistantMessage();
-          }
-          return;
-        }
-
-        case "message_update": {
-          const update = event.assistantMessageEvent;
-          if (update.type === "text_delta") {
-            emit({
-              type: "message.delta",
-              runId: options.runId,
-              messageId: ensureAssistantMessage(),
-              text: update.delta,
-            });
-          }
-          if (update.type === "thinking_delta") {
-            emit({
-              type: "thinking.delta",
-              runId: options.runId,
-              text: update.delta,
-            });
-          }
-          if (update.type === "thinking_end") {
-            emit({
-              type: "thinking.completed",
-              runId: options.runId,
-              text: update.content,
-            });
-          }
-          return;
-        }
-
-        case "message_end": {
-          const message = event.message as Message;
-          if (message.role === "assistant") completeAssistantMessage(message);
-          return;
-        }
-
-        case "tool_execution_start": {
-          const messageId = messageIdForTool();
-          emit({
-            type: "tool.started",
-            runId: options.runId,
-            toolCallId: event.toolCallId,
-            messageId,
-            name: event.toolName,
-            input: event.args,
-          });
-          return;
-        }
-
-        case "tool_execution_update":
-          emit({
-            type: "tool.delta",
-            runId: options.runId,
-            toolCallId: event.toolCallId,
-            chunk: event.partialResult,
-          });
-          return;
-
-        case "tool_execution_end": {
-          const output = toolOutput(event.result, event.isError);
-          if (event.isError) {
-            emit({
-              type: "tool.failed",
-              runId: options.runId,
-              toolCallId: event.toolCallId,
-              error: {
-                message: messageText(output.content),
-                details: output.details,
-              },
-            });
-          } else {
-            emit({
-              type: "tool.completed",
-              runId: options.runId,
-              toolCallId: event.toolCallId,
-              output,
-            });
-          }
-          return;
-        }
-      }
-    },
-    nextSeq() {
-      return seq;
-    },
-  };
-}
-
-function contentToChatContent(content: AssistantMessage["content"]): MessageContent[] {
-  return content.flatMap((part): MessageContent[] => {
-    if (part.type === "text") return [{ type: "text", text: part.text }];
-    if (part.type === "toolCall") return [{ type: "tool", toolCallId: part.id }];
-    return [];
-  });
-}
-
-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
-        : "",
-    )
-    .join("");
-}
-
-function userMessageContent(content: unknown, text: string): MessageContent[] {
-  const parts: MessageContent[] = [{ type: "text", text }];
-  if (!Array.isArray(content)) return parts;
-  for (const part of content) {
-    const record = asRecord(part);
-    if (record.type !== "image") continue;
-    const alt = typeof record.alt === "string" ? record.alt : undefined;
-    if (typeof record.url === "string") {
-      parts.push({ type: "image", url: record.url, alt });
-      continue;
-    }
-    if (typeof record.data === "string" && typeof record.mimeType === "string") {
-      parts.push({
-        type: "image",
-        url: `data:${record.mimeType};base64,${record.data}`,
-        data: record.data,
-        mimeType: record.mimeType,
-        alt,
-      });
-    }
-  }
-  return parts;
-}
-
-function toolOutput(result: unknown, isError: boolean): ToolOutput {
-  const record = asRecord(result);
-  return {
-    content: Array.isArray(record.content) ? (record.content as ToolOutput["content"]) : [],
-    details: record.details,
-    isError,
-  };
-}
-
-function asRecord(value: unknown): Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : {};
-}

package/gui/server/local-session-coordinator.ts

@@ -1,97 +0,0 @@
-export type SessionActionType =
-  | "chat.prompt"
-  | "tool.invoke"
-  | "ask_user.answer"
-  | "ask_user.cancel"
-  | "run.cancel";
-
-export type SessionActionSource = "gui" | "tui" | "browser";
-
-export interface SessionActionEnvelope {
-  sessionId: string;
-  actionId: string;
-  actionType: SessionActionType;
-  payload: Record<string, unknown>;
-  source: SessionActionSource;
-}
-
-export type SessionActionResult<T = unknown> =
-  | { ok: true; duplicate: boolean; result: T }
-  | { ok: false; code: "session_busy"; message: string };
-
-export interface LocalSessionCoordinator {
-  runSessionAction<T>(
-    action: SessionActionEnvelope,
-    handler: (action: SessionActionEnvelope) => Promise<T>,
-  ): Promise<SessionActionResult<T>>;
-}
-
-export interface LocalSessionCoordinatorOptions {
-  dedupeRetentionMs?: number;
-  now?: () => number;
-}
-
-interface AcceptedAction {
-  expiresAt: number;
-  result: unknown;
-}
-
-const DEFAULT_DEDUPE_RETENTION_MS = 10 * 60 * 1000;
-const BUSY_MESSAGE = "OpenCandle is still working in this session. Try again when it finishes.";
-
-export function createLocalSessionCoordinator(
-  options: LocalSessionCoordinatorOptions = {},
-): LocalSessionCoordinator {
-  const now = options.now ?? Date.now;
-  const dedupeRetentionMs = options.dedupeRetentionMs ?? DEFAULT_DEDUPE_RETENTION_MS;
-  const acceptedActions = new Map<string, AcceptedAction>();
-  const activeActions = new Map<string, Promise<unknown>>();
-  const activeRunSessions = new Set<string>();
-
-  async function runSessionAction<T>(
-    action: SessionActionEnvelope,
-    handler: (action: SessionActionEnvelope) => Promise<T>,
-  ): Promise<SessionActionResult<T>> {
-    pruneExpiredActions();
-    const actionKey = `${action.sessionId}:${action.actionId}`;
-    const accepted = acceptedActions.get(actionKey);
-    if (accepted) return { ok: true, duplicate: true, result: accepted.result as T };
-    const active = activeActions.get(actionKey);
-    if (active) return { ok: true, duplicate: true, result: (await active) as T };
-
-    if (isRunAdmissionAction(action) && activeRunSessions.has(action.sessionId)) {
-      return { ok: false, code: "session_busy", message: BUSY_MESSAGE };
-    }
-
-    if (isRunAdmissionAction(action)) activeRunSessions.add(action.sessionId);
-    const runAction = (async () => {
-      const result = await handler(action);
-      acceptedActions.set(actionKey, {
-        expiresAt: now() + dedupeRetentionMs,
-        result,
-      });
-      return result;
-    })();
-    activeActions.set(actionKey, runAction);
-    try {
-      const result = await runAction;
-      return { ok: true, duplicate: false, result };
-    } finally {
-      activeActions.delete(actionKey);
-      if (isRunAdmissionAction(action)) activeRunSessions.delete(action.sessionId);
-    }
-  }
-
-  function pruneExpiredActions(): void {
-    const currentTime = now();
-    for (const [actionKey, accepted] of acceptedActions) {
-      if (accepted.expiresAt <= currentTime) acceptedActions.delete(actionKey);
-    }
-  }
-
-  return { runSessionAction };
-}
-
-function isRunAdmissionAction(action: SessionActionEnvelope): boolean {
-  return action.actionType === "chat.prompt" || action.actionType === "tool.invoke";
-}

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

@@ -1,331 +0,0 @@
-import type Database from "better-sqlite3";
-import { buildFreshnessStamp } from "../../src/infra/freshness.js";
-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"]>;
-  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 | null;
-    changePercent?: number;
-    marketValue?: number | null;
-    totalCost: number;
-    pnl?: number | null;
-    pnlPercent?: number | null;
-    allocationPercent?: number;
-    currency: string;
-    includedInTotals: boolean;
-    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 }>;
-  };
-}
-
-interface SavedSymbolsMemoOptions {
-  ttlMs?: number;
-  now?: () => number;
-}
-
-export function createSavedSymbolsMemo(
-  load: () => string[],
-  options: SavedSymbolsMemoOptions = {},
-): () => string[] {
-  const ttlMs = options.ttlMs ?? 30_000;
-  const now = options.now ?? Date.now;
-  let cachedAt = 0;
-  let cached: string[] | null = null;
-  return () => {
-    const current = now();
-    if (cached && current - cachedAt < ttlMs) return cached;
-    cached = load();
-    cachedAt = current;
-    return cached;
-  };
-}
-
-export const getSavedMarketStateSymbols = createSavedSymbolsMemo(loadSavedMarketStateSymbols);
-
-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(),
-      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();
-  }
-}
-
-function loadSavedMarketStateSymbols(): string[] {
-  const db = initDefaultDatabase();
-  const service = new MarketStateService(db);
-  try {
-    const symbols = [
-      ...service.listWatchlistItems().map((item) => item.symbol),
-      ...service.listPortfolioLots().map((lot) => lot.symbol),
-    ];
-    return normalizeSymbols(symbols);
-  } finally {
-    db.close();
-  }
-}
-
-function normalizeSymbols(symbols: string[]): string[] {
-  const normalized: string[] = [];
-  for (const symbol of symbols) {
-    const next = symbol.trim().toUpperCase();
-    if (!next || normalized.includes(next)) continue;
-    normalized.push(next);
-  }
-  return normalized;
-}
-
-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 symbols = [
-      ...new Set([...watchlist.map((item) => item.symbol), ...portfolio.map((lot) => lot.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",
-      }));
-    return {
-      generatedAt,
-      watchlistQuotes,
-      portfolioQuotes: portfolioQuotesWithAllocation,
-      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." };
-  }
-  const freshness = buildFreshnessStamp({
-    asOf: result.data.asOf,
-    cached: result.cached,
-    stale: result.stale,
-    cachedAt: result.timestamp,
-  });
-  if (freshness.isStaleForSession) {
-    return { status: "unavailable", reason: "provider returned stale market data" };
-  }
-  return {
-    status: "ok",
-    price: result.data.price,
-    changePercent: result.data.changePercent,
-    fetchedAt: freshness.providerDataAt ?? result.timestamp,
-    stale: result.stale,
-    currency: result.data.currency ?? null,
-  };
-}