opencandle 0.10.0 → 0.11.1

package/gui/server/invoke-tool.ts

@@ -4,14 +4,24 @@ import type { SessionManager } from "@earendil-works/pi-coding-agent";
 import type { TSchema } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 import { getDefaults } from "../../src/memory/tool-defaults.js";
+import {
+  clearPendingSessionAction,
+  hasAcceptedSessionAction,
+  hasPendingSessionAction,
+  recordAcceptedSessionAction,
+  recordPendingSessionAction,
+} from "../../src/pi/session-action-dedupe.js";
 import { wrapWithDefaults } from "../../src/runtime/tool-defaults-wrapper.js";
 import { getAllTools } from "../../src/tools/index.js";
 import type { AskUserHandler } from "../../src/types/index.js";
+import type { LocalSessionCoordinator } from "./local-session-coordinator.js";
 import { buildToolInvokeAckMessage } from "./tool-invoke-ack.js";
 import {
   acquireWriterLock,
+  readWriterLock,
   refreshWriterLock,
   releaseWriterLock,
+  shouldBlockFailedCoordinatorAction,
   writerLockScopeForSession,
 } from "./writer-lock.js";
 
@@ -30,6 +40,7 @@ export interface ToolInvokeController {
     toolName: string,
     args: Record<string, unknown>,
     sessionId?: string,
+    options?: { actionId?: string; allowProxy?: boolean },
   ): Promise<InvokeToolResult>;
   handleToolInvokeMessage(client: ToolInvokeClient, data: Record<string, unknown>): Promise<void>;
 }
@@ -46,6 +57,10 @@ export interface ToolInvokeControllerOptions {
   resolveSessionManager?: (sessionId: string) => Promise<SessionManager | null>;
   broadcastSessionSnapshot?: (sessionManager: SessionManager) => void;
   broadcastSessions?: () => void;
+  localSessionCoordinator?: LocalSessionCoordinator;
+  localCoordinatorEndpoint?: string;
+  localCoordinatorSecret?: string;
+  syncWriterLockScope?: () => void;
 }
 
 export function createToolInvokeController({
@@ -60,13 +75,17 @@ export function createToolInvokeController({
   resolveSessionManager,
   broadcastSessionSnapshot,
   broadcastSessions,
+  localSessionCoordinator,
+  localCoordinatorEndpoint,
+  localCoordinatorSecret,
+  syncWriterLockScope,
 }: ToolInvokeControllerOptions): ToolInvokeController {
   async function handleToolInvoke(
     toolName: string,
     args: Record<string, unknown>,
     sessionId = "",
+    options: { actionId?: string; allowProxy?: boolean } = {},
   ): 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}`);
 
@@ -77,15 +96,50 @@ export function createToolInvokeController({
       resolveSessionManager,
     );
     const useCurrentSession = sameSessionStorage(currentSessionManager, runSessionManager);
+    const allowProxy = options.allowProxy !== false;
+    const shouldProxyToolInvoke =
+      allowProxy &&
+      (role !== "writer" || !useCurrentSession) &&
+      canProxyToolInvokeToCoordinator(runSessionManager);
+    if (shouldProxyToolInvoke) {
+      const proxied = await proxyToolInvokeToCoordinator(
+        runSessionManager,
+        toolName,
+        args,
+        options.actionId,
+      );
+      if (proxied) return proxied;
+      if (options.actionId && hasAcceptedSessionAction(runSessionManager, options.actionId)) {
+        throw new Error("OpenCandle already accepted this action in the active session.");
+      }
+      if (options.actionId && hasPendingSessionAction(runSessionManager, options.actionId)) {
+        throw new Error("OpenCandle is reconnecting to this session.");
+      }
+      if (options.actionId && shouldBlockFailedCoordinatorAction(runSessionManager)) {
+        throw new Error("OpenCandle is reconnecting to this session.");
+      }
+    }
+    if (options.actionId && hasAcceptedSessionAction(runSessionManager, options.actionId)) {
+      throw new Error("OpenCandle already accepted this action in the active session.");
+    }
+    if (options.actionId && hasPendingSessionAction(runSessionManager, options.actionId)) {
+      throw new Error("OpenCandle is reconnecting to this session.");
+    }
     let acquiredLockScope = "";
     let lockHeartbeat: ReturnType<typeof setInterval> | undefined;
-    if (!useCurrentSession) {
+    const needsWriterLock = !useCurrentSession || role !== "writer";
+    // The writer fast path must fail closed like chat runs when this process
+    // lost its lock scope migration, or it can double-write to a session
+    // another process now owns.
+    if (!needsWriterLock) syncWriterLockScope?.();
+    if (needsWriterLock) {
       const lockScope = writerLockScopeForSession(runSessionManager);
-      const lockResult = await acquireWriterLock(lockScope, "gui");
+      const lockResult = await acquireWriterLock(lockScope, "gui", {
+        coordinatorEndpoint: localCoordinatorEndpoint,
+        coordinatorSecret: localCoordinatorSecret,
+      });
       if (lockResult.role !== "writer") {
-        throw new Error(
-          `Session is currently being written by ${lockResult.lock.processKind} (pid ${lockResult.lock.pid}).`,
-        );
+        throw new Error("OpenCandle is reconnecting to this session.");
       }
       acquiredLockScope = lockScope;
       lockHeartbeat = setInterval(() => refreshWriterLock(lockScope), 5000);
@@ -93,12 +147,27 @@ export function createToolInvokeController({
 
     try {
       const runSessionId = safeSessionId(runSessionManager);
-      const result = await invokeTool(runSessionManager, tool, args, "ui", {
-        askUserHandler:
-          runSessionId && askUserHandlerForSessionId
-            ? askUserHandlerForSessionId(runSessionId)
-            : askUserHandler,
-      });
+      recordPendingSessionAction(runSessionManager, options.actionId ?? "");
+      let actionAccepted = false;
+      const recordAcceptedAction = () => {
+        if (actionAccepted) return;
+        recordAcceptedSessionAction(runSessionManager, options.actionId ?? "");
+        actionAccepted = true;
+      };
+      let result: InvokeToolResult;
+      try {
+        result = await invokeTool(runSessionManager, tool, args, "ui", {
+          askUserHandler:
+            runSessionId && askUserHandlerForSessionId
+              ? askUserHandlerForSessionId(runSessionId)
+              : askUserHandler,
+          onTranscriptStarted: recordAcceptedAction,
+        });
+      } catch (error) {
+        if (!actionAccepted) clearPendingSessionAction(runSessionManager, options.actionId ?? "");
+        throw error;
+      }
+      recordAcceptedAction();
       if (!result.isError && marketStateToolMapping(toolName) != null) {
         onMarketStateChanged?.();
       }
@@ -120,10 +189,29 @@ export function createToolInvokeController({
     data: Record<string, unknown>,
   ): Promise<void> {
     const requestId = typeof data.requestId === "string" ? data.requestId : "";
+    const actionId = typeof data.actionId === "string" ? data.actionId : "";
     const toolName = String(data.toolName ?? "");
     const sessionId = typeof data.sessionId === "string" ? data.sessionId : "";
+    const allowProxy = data.allowProxy !== false;
     try {
-      const result = await handleToolInvoke(toolName, requestArgs(data.args), sessionId);
+      if (!sessionId.trim()) throw new Error("sessionId is required");
+      if (!actionId.trim()) throw new Error("actionId is required");
+      const invoke = () =>
+        handleToolInvoke(toolName, requestArgs(data.args), sessionId, { actionId, allowProxy });
+      const actionResult = localSessionCoordinator
+        ? await localSessionCoordinator.runSessionAction(
+            {
+              sessionId,
+              actionId,
+              actionType: "tool.invoke",
+              payload: { toolName, args: requestArgs(data.args) },
+              source: "browser",
+            },
+            invoke,
+          )
+        : await invoke().then((result) => ({ ok: true as const, duplicate: false, result }));
+      if (!actionResult.ok) throw new Error(actionResult.message);
+      const result = actionResult.result;
       if (requestId) {
         client.send(buildToolInvokeAckMessage(requestId, toolName, result));
       }
@@ -146,6 +234,64 @@ export function createToolInvokeController({
   return { handleToolInvoke, handleToolInvokeMessage };
 }
 
+export function canProxyToolInvokeToCoordinator(runSessionManager: SessionManager): boolean {
+  let lockScope: string;
+  try {
+    lockScope = writerLockScopeForSession(runSessionManager);
+  } catch {
+    return false;
+  }
+  const lock = readWriterLock(lockScope);
+  return Boolean(
+    lock?.processKind === "gui" &&
+      lock.coordinatorEndpoint &&
+      lock.coordinatorSecret &&
+      lock.pid !== process.pid,
+  );
+}
+
+async function proxyToolInvokeToCoordinator(
+  runSessionManager: SessionManager,
+  toolName: string,
+  args: Record<string, unknown>,
+  actionId = "",
+): Promise<InvokeToolResult | null> {
+  const lock = readWriterLock(writerLockScopeForSession(runSessionManager));
+  if (!lock?.coordinatorEndpoint || !lock.coordinatorSecret) return null;
+  const endpoint = new URL("/api/local-coordinator/tool-invoke", lock.coordinatorEndpoint);
+  let response: Response;
+  try {
+    response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-opencandle-coordinator-secret": lock.coordinatorSecret,
+      },
+      body: JSON.stringify({
+        sessionId: safeSessionId(runSessionManager),
+        actionId,
+        toolName,
+        args,
+      }),
+    });
+  } catch {
+    return null;
+  }
+  const body = asRecord(await response.json());
+  const ackResult = asRecord(body.result);
+  if (!response.ok || !ackResult.toolCallId) {
+    throw new Error(String(body.error ?? "OpenCandle is reconnecting to this session."));
+  }
+  return {
+    toolCallId: String(ackResult.toolCallId),
+    result: {
+      content: Array.isArray(ackResult.content) ? ackResult.content : [],
+      details: ackResult.details,
+    },
+    isError: Boolean(ackResult.isError),
+  };
+}
+
 function sameSessionStorage(current: SessionManager, target: SessionManager): boolean {
   if (current === target) return true;
   const currentFile = safeSessionFile(current);
@@ -192,7 +338,11 @@ export async function invokeToolFromUi(
   tool: AgentTool<TSchema, unknown>,
   args: Record<string, unknown>,
   source: "ui" | "background" = "ui",
-  options: { askUserHandler?: AskUserHandler; recordTranscript?: boolean } = {},
+  options: {
+    askUserHandler?: AskUserHandler;
+    recordTranscript?: boolean;
+    onTranscriptStarted?: () => void;
+  } = {},
 ): Promise<InvokeToolResult> {
   if (!Value.Check(tool.parameters, args)) {
     const errors = [...Value.Errors(tool.parameters, args)]
@@ -222,6 +372,7 @@ export async function invokeToolFromUi(
   const recordTranscript = options.recordTranscript ?? true;
   if (recordTranscript) {
     sessionManager.appendMessage(assistant);
+    options.onTranscriptStarted?.();
   }
 
   const wrapped = wrapWithDefaults(tool, getDefaults(tool.name));
@@ -299,8 +450,6 @@ function marketStateToolMapping(toolName: string): { domain: string; targetType:
       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":

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

@@ -1,6 +1,11 @@
 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";
+import type {
+  ChatEvent,
+  MessageAttachmentChip,
+  MessageContent,
+  ToolOutput,
+} from "../shared/chat-events.js";
 
 export interface LiveChatEventAdapterOptions {
   runId: string;
@@ -12,6 +17,7 @@ export interface LiveChatEventAdapterOptions {
    * message with an expanded prompt; the live view renders this instead.
    */
   originalPrompt?: string;
+  originalAttachments?: MessageAttachmentChip[];
 }
 
 export interface LiveChatEventAdapter {
@@ -77,7 +83,12 @@ export function createLiveChatEventAdapter(
               type: "message.completed",
               runId: options.runId,
               messageId,
-              content: [{ type: "text", text }],
+              content: userMessageContent(message.content, text),
+              ...(userCount === 1 &&
+              options.originalAttachments &&
+              options.originalAttachments.length > 0
+                ? { attachments: options.originalAttachments }
+                : {}),
             });
             return;
           }
@@ -192,6 +203,30 @@ function messageText(content: unknown): string {
     .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 {

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

@@ -0,0 +1,97 @@
+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,4 +1,5 @@
 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";
@@ -9,7 +10,6 @@ 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"]>;
@@ -38,12 +38,12 @@ export interface MarketStateQuoteSnapshot {
     instrumentId: number;
     symbol: string;
     status: "ok" | "unavailable";
-    currentPrice?: number;
+    currentPrice?: number | null;
     changePercent?: number;
-    marketValue?: number;
+    marketValue?: number | null;
     totalCost: number;
-    pnl?: number;
-    pnlPercent?: number;
+    pnl?: number | null;
+    pnlPercent?: number | null;
     allocationPercent?: number;
     currency: string;
     includedInTotals: boolean;
@@ -51,17 +51,6 @@ export interface MarketStateQuoteSnapshot {
     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;
@@ -72,6 +61,30 @@ export interface MarketStateQuoteSnapshot {
   };
 }
 
+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);
@@ -86,7 +99,6 @@ export function buildMarketStateSnapshot(db?: Database.Database): MarketStateSna
         .filter((instrument) => instrument != null),
       watchlist: service.listWatchlistItems(),
       portfolio: service.listPortfolioLots(),
-      predictions: service.listPredictions(),
       alerts,
       alertEvents: service.listAlertEvents(),
       alertCheckRuns: service.listAlertCheckRuns(),
@@ -101,6 +113,30 @@ export function buildMarketStateSnapshot(db?: Database.Database): MarketStateSna
   }
 }
 
+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> {
@@ -109,13 +145,8 @@ export async function buildMarketStateQuoteSnapshot(
   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),
-      ]),
+      ...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) {
@@ -224,34 +255,10 @@ export async function buildMarketStateQuoteSnapshot(
         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,
@@ -304,11 +311,20 @@ async function fetchQuoteSnapshot(symbol: string): Promise<
   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: result.timestamp,
+    fetchedAt: freshness.providerDataAt ?? result.timestamp,
     stale: result.stale,
     currency: result.data.currency ?? null,
   };