opencandle 0.5.0 → 0.7.0

package/gui/server/background-quotes.ts

@@ -1,5 +1,10 @@
-import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 import type { ToolResultMessage } from "@earendil-works/pi-ai";
+import type { SessionEntry, SessionManager } from "@earendil-works/pi-coding-agent";
+import { getAllTools } from "../../src/tools/index.js";
+import { invokeToolFromUi } from "./invoke-tool.js";
+import { projectDashboard } from "./projector.js";
+
+export const BACKGROUND_QUOTE_POLL_INTERVAL_MS = 30_000;
 
 export interface BackgroundQuoteRefresh {
   symbol: string;
@@ -29,3 +34,94 @@ export class BackgroundQuoteRefreshes {
     return [...entries, ...this.entriesBySymbol.values()];
   }
 }
+
+type IntervalHandle = ReturnType<typeof setInterval>;
+type SetIntervalFn = (callback: () => void, ms: number) => IntervalHandle;
+type ClearIntervalFn = (handle: IntervalHandle) => void;
+
+export interface BackgroundQuotePoller {
+  updatePoller(): void;
+  pollVisibleQuotes(): Promise<void>;
+  stop(): void;
+}
+
+export interface BackgroundQuotePollerOptions {
+  getClientCount: () => number;
+  getSessionManager: () => SessionManager;
+  refreshes: BackgroundQuoteRefreshes;
+  broadcastState: () => void;
+  getTools?: typeof getAllTools;
+  invokeTool?: typeof invokeToolFromUi;
+  setIntervalFn?: SetIntervalFn;
+  clearIntervalFn?: ClearIntervalFn;
+  warn?: (message: string) => void;
+}
+
+export function createBackgroundQuotePoller({
+  getClientCount,
+  getSessionManager,
+  refreshes,
+  broadcastState,
+  getTools = getAllTools,
+  invokeTool = invokeToolFromUi,
+  setIntervalFn = setInterval,
+  clearIntervalFn = clearInterval,
+  warn = (message) => console.warn(message),
+}: BackgroundQuotePollerOptions): BackgroundQuotePoller {
+  let poller: IntervalHandle | null = null;
+  let quotePollInFlight = false;
+
+  async function pollVisibleQuotes(): Promise<void> {
+    if (quotePollInFlight) return;
+    quotePollInFlight = true;
+    try {
+      const sessionManager = getSessionManager();
+      const state = projectDashboard(sessionManager.getEntries(), sessionManager.getSessionId());
+      const tool = getTools().find((candidate) => candidate.name === "get_stock_quote");
+      if (!tool) return;
+      for (const row of state.watchlist.filter((item) => item.pinned || item.quote)) {
+        const result = await invokeTool(
+          sessionManager,
+          tool,
+          { symbol: row.symbol },
+          "background",
+          { recordTranscript: false },
+        );
+        refreshes.upsert({
+          symbol: row.symbol,
+          toolName: tool.name,
+          args: { symbol: row.symbol },
+          value: result.result.details,
+          content: result.result.content,
+          isError: result.isError,
+        });
+      }
+      broadcastState();
+    } catch (error) {
+      warn(
+        `Background quote refresh failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    } finally {
+      quotePollInFlight = false;
+    }
+  }
+
+  function updatePoller(): void {
+    if (getClientCount() > 0 && !poller) {
+      poller = setIntervalFn(() => void pollVisibleQuotes(), BACKGROUND_QUOTE_POLL_INTERVAL_MS);
+    }
+    if (getClientCount() === 0 && poller) {
+      clearIntervalFn(poller);
+      poller = null;
+    }
+  }
+
+  function stop(): void {
+    if (poller) {
+      clearIntervalFn(poller);
+      poller = null;
+    }
+  }
+
+  return { updatePoller, pollVisibleQuotes, stop };
+}

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

@@ -1,5 +1,5 @@
-import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 import type { Message, ToolResultMessage } from "@earendil-works/pi-ai";
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 import type { ChatEvent, MessageContent, ToolOutput } from "../shared/chat-events.js";
 
 export interface SessionEventOptions {
@@ -16,6 +16,9 @@ export function sessionEntriesToChatEvents(
   let seq = options.startSeq ?? 1;
   const events: ChatEvent[] = [];
   const seenToolCalls = new Set<string>();
+  // Set by an opencandle-user-input marker: the user's words before a workflow
+  // transform expanded the turn. The next user message renders this instead.
+  let pendingOriginalInput: string | null = null;
   const updatedAt = options.updatedAt ?? entries.at(-1)?.timestamp ?? new Date().toISOString();
 
   events.push({
@@ -27,12 +30,17 @@ export function sessionEntriesToChatEvents(
   });
 
   for (const entry of entries) {
+    if (isOriginalInputEntry(entry)) {
+      pendingOriginalInput = originalInputText(entry);
+      continue;
+    }
+
     if (entry.type === "custom_message") {
       const messageId = entry.id;
-      events.push({ type: "message.created", messageId, role: "assistant", seq: seq++ });
       events.push({
-        type: "message.completed",
+        type: "custom.message",
         messageId,
+        customType: String((entry as { customType?: unknown }).customType || "custom"),
         content: [{ type: "text", text: customMessageText(entry.content) }],
         seq: seq++,
       });
@@ -48,9 +56,10 @@ export function sessionEntriesToChatEvents(
       events.push({
         type: "message.completed",
         messageId,
-        content: [{ type: "text", text: messageText(message.content) }],
+        content: [{ type: "text", text: pendingOriginalInput ?? messageText(message.content) }],
         seq: seq++,
       });
+      pendingOriginalInput = null;
       continue;
     }
 
@@ -109,6 +118,20 @@ export function sessionEntriesToChatEvents(
   return events;
 }
 
+export function isOriginalInputEntry(entry: SessionEntry): boolean {
+  return (
+    entry.type === "custom" &&
+    (entry as { customType?: unknown }).customType === "opencandle-user-input"
+  );
+}
+
+export function originalInputText(entry: SessionEntry): string | null {
+  const data = (entry as { data?: { original?: unknown } }).data;
+  return typeof data?.original === "string" && data.original.trim().length > 0
+    ? data.original
+    : null;
+}
+
 function customMessageText(content: unknown): string {
   if (typeof content === "string") return content;
   return messageText(content);
@@ -117,16 +140,15 @@ function customMessageText(content: unknown): string {
 function messageText(content: unknown): string {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
-  return content
-    .map((part) => typeof part.text === "string" ? part.text : "")
-    .join("");
+  return content.map((part) => (typeof part.text === "string" ? part.text : "")).join("");
 }
 
 function toolOutput(message: ToolResultMessage): ToolOutput {
   const details = message.details;
-  const source = typeof details === "object" && details !== null && "source" in details
-    ? String((details as { source?: unknown }).source ?? "")
-    : undefined;
+  const source =
+    typeof details === "object" && details !== null && "source" in details
+      ? String((details as { source?: unknown }).source ?? "")
+      : undefined;
   return {
     content: message.content,
     details,

package/gui/server/chat-run-session.ts

@@ -0,0 +1,16 @@
+export interface ChatRunSessionConflict {
+  error: string;
+  code: "session_changed";
+}
+
+export function chatRunSessionConflict(
+  expectedSessionId: unknown,
+  activeSessionId: string,
+): ChatRunSessionConflict | null {
+  const expected = typeof expectedSessionId === "string" ? expectedSessionId.trim() : "";
+  if (!expected || expected === activeSessionId) return null;
+  return {
+    error: "The active session changed before this message was sent.",
+    code: "session_changed",
+  };
+}

package/gui/server/invoke-tool.ts

@@ -5,6 +5,9 @@ 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 type { AskUserHandler } from "../../src/types/index.js";
+import { buildToolInvokeAckMessage } from "./tool-invoke-ack.js";
 
 export interface InvokeToolResult {
   toolCallId: string;
@@ -12,12 +15,89 @@ 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;
+  askUserHandler?: AskUserHandler;
+}
+
+export function createToolInvokeController({
+  role,
+  getSessionManager,
+  broadcastState,
+  onMarketStateChanged,
+  getTools = getAllTools,
+  invokeTool = invokeToolFromUi,
+  askUserHandler,
+}: 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", { askUserHandler });
+    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>,
   args: Record<string, unknown>,
   source: "ui" | "background" = "ui",
-  options: { recordTranscript?: boolean } = {},
+  options: { askUserHandler?: AskUserHandler; recordTranscript?: boolean } = {},
 ): Promise<InvokeToolResult> {
   if (!Value.Check(tool.parameters, args)) {
     const errors = [...Value.Errors(tool.parameters, args)]
@@ -53,7 +133,18 @@ export async function invokeToolFromUi(
   let result: AgentToolResult<unknown>;
   let isError = false;
   try {
-    result = await wrapped.execute(toolCallId, args as never);
+    result = await (
+      wrapped.execute as (
+        id: string,
+        params: never,
+        signal: AbortSignal | undefined,
+        onUpdate: undefined,
+        ctx: { askUserHandler?: AskUserHandler; hasUI: false },
+      ) => ReturnType<typeof wrapped.execute>
+    )(toolCallId, args as never, undefined, undefined, {
+      askUserHandler: options.askUserHandler,
+      hasUI: false,
+    });
   } catch (error) {
     isError = true;
     result = {
@@ -68,7 +159,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 +173,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>)
     : {};
 }