opencandle 0.11.1 → 0.12.0

package/dist/gui/server/background-quotes.js

@@ -0,0 +1,71 @@
+import { getAllTools } from "../../tools/index.js";
+import { invokeToolFromUi } from "./invoke-tool.js";
+import { projectDashboard } from "./projector.js";
+export const BACKGROUND_QUOTE_POLL_INTERVAL_MS = 30_000;
+export class BackgroundQuoteRefreshes {
+    entriesBySymbol = new Map();
+    upsert(refresh) {
+        const timestamp = new Date().toISOString();
+        this.entriesBySymbol.set(refresh.symbol, {
+            type: "custom",
+            id: `background-quote-${refresh.symbol}`,
+            parentId: null,
+            timestamp,
+            customType: "opencandle-quote-refresh",
+            data: refresh,
+        });
+    }
+    withEntries(entries) {
+        return [...entries, ...this.entriesBySymbol.values()];
+    }
+}
+export function createBackgroundQuotePoller({ getClientCount, getSessionManager, refreshes, broadcastState, getTools = getAllTools, invokeTool = invokeToolFromUi, setIntervalFn = setInterval, clearIntervalFn = clearInterval, warn = (message) => console.warn(message), }) {
+    let poller = null;
+    let quotePollInFlight = false;
+    async function pollVisibleQuotes() {
+        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() {
+        if (getClientCount() > 0 && !poller) {
+            poller = setIntervalFn(() => void pollVisibleQuotes(), BACKGROUND_QUOTE_POLL_INTERVAL_MS);
+        }
+        if (getClientCount() === 0 && poller) {
+            clearIntervalFn(poller);
+            poller = null;
+        }
+    }
+    function stop() {
+        if (poller) {
+            clearIntervalFn(poller);
+            poller = null;
+        }
+    }
+    return { updatePoller, pollVisibleQuotes, stop };
+}

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

@@ -0,0 +1,16 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { ChatEvent } from "../shared/chat-events.js";
+export interface SessionEventOptions {
+    sessionId: string;
+    title?: string;
+    updatedAt?: string;
+    startSeq?: number;
+    markUnresolvedToolCalls?: boolean;
+}
+export declare function sessionEntriesToChatEvents(entries: SessionEntry[], options: SessionEventOptions): ChatEvent[];
+export declare function isOriginalInputEntry(entry: SessionEntry): boolean;
+export declare function originalInputText(entry: SessionEntry): string | null;
+export declare function originalInputAttachments(entry: SessionEntry): Array<{
+    kind: string;
+    label: string;
+}>;

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

@@ -0,0 +1,263 @@
+export function sessionEntriesToChatEvents(entries, options) {
+    let seq = options.startSeq ?? 1;
+    const events = [];
+    const seenToolCalls = new Set();
+    const resolvedToolCalls = new Set();
+    const pendingToolCalls = new Map();
+    // 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 = null;
+    let pendingOriginalAttachments = [];
+    let lastEntryWasUserMessage = false;
+    let lastUserCompletedEventIndex = null;
+    const updatedAt = options.updatedAt ?? entries.at(-1)?.timestamp ?? new Date().toISOString();
+    events.push({
+        type: "session.updated",
+        sessionId: options.sessionId,
+        title: options.title,
+        updatedAt,
+        seq: seq++,
+    });
+    for (const entry of entries) {
+        if (isOriginalInputEntry(entry)) {
+            const originalInput = originalInputText(entry);
+            const originalAttachments = originalInputAttachments(entry);
+            if (lastEntryWasUserMessage && lastUserCompletedEventIndex != null) {
+                applyOriginalInput(events[lastUserCompletedEventIndex], originalInput, originalAttachments);
+            }
+            else {
+                pendingOriginalInput = originalInput;
+                pendingOriginalAttachments = originalAttachments;
+            }
+            lastEntryWasUserMessage = false;
+            continue;
+        }
+        if (entry.type === "custom_message") {
+            lastEntryWasUserMessage = false;
+            const messageId = entry.id;
+            events.push({
+                type: "custom.message",
+                sessionId: options.sessionId,
+                messageId,
+                customType: String(entry.customType || "custom"),
+                content: [{ type: "text", text: customMessageText(entry.content) }],
+                details: entry.details,
+                seq: seq++,
+            });
+            continue;
+        }
+        if (entry.type !== "message") {
+            lastEntryWasUserMessage = false;
+            continue;
+        }
+        const message = entry.message;
+        const messageId = entry.id;
+        if (message.role === "user") {
+            events.push({
+                type: "message.created",
+                sessionId: options.sessionId,
+                messageId,
+                role: "user",
+                seq: seq++,
+            });
+            const completedEvent = {
+                type: "message.completed",
+                sessionId: options.sessionId,
+                messageId,
+                content: userMessageContent(message.content, pendingOriginalInput),
+                ...(pendingOriginalAttachments.length > 0
+                    ? { attachments: pendingOriginalAttachments }
+                    : {}),
+                seq: seq++,
+            };
+            events.push(completedEvent);
+            lastUserCompletedEventIndex = events.length - 1;
+            lastEntryWasUserMessage = true;
+            pendingOriginalInput = null;
+            pendingOriginalAttachments = [];
+            continue;
+        }
+        if (message.role === "assistant") {
+            lastEntryWasUserMessage = false;
+            events.push({
+                type: "message.created",
+                sessionId: options.sessionId,
+                messageId,
+                role: "assistant",
+                seq: seq++,
+            });
+            const content = [];
+            for (const part of Array.isArray(message.content) ? message.content : []) {
+                if (part.type === "text") {
+                    content.push({ type: "text", text: part.text });
+                    continue;
+                }
+                if (part.type === "toolCall") {
+                    seenToolCalls.add(part.id);
+                    pendingToolCalls.set(part.id, { name: part.name });
+                    content.push({ type: "tool", toolCallId: part.id });
+                    events.push({
+                        type: "tool.started",
+                        sessionId: options.sessionId,
+                        toolCallId: part.id,
+                        messageId,
+                        name: part.name,
+                        input: part.arguments,
+                        seq: seq++,
+                    });
+                }
+                if (part.type === "image") {
+                    content.push({ type: "image", url: part.url });
+                }
+            }
+            events.push({
+                type: "message.completed",
+                sessionId: options.sessionId,
+                messageId,
+                content,
+                seq: seq++,
+            });
+            continue;
+        }
+        if (message.role === "toolResult") {
+            lastEntryWasUserMessage = false;
+            const tool = message;
+            const toolCallId = tool.toolCallId || `tool-${entry.id}`;
+            resolvedToolCalls.add(toolCallId);
+            pendingToolCalls.delete(toolCallId);
+            if (!seenToolCalls.has(toolCallId)) {
+                events.push({
+                    type: "tool.started",
+                    sessionId: options.sessionId,
+                    toolCallId,
+                    messageId,
+                    name: tool.toolName || "tool",
+                    input: inputFromDetails(tool.details),
+                    seq: seq++,
+                });
+            }
+            events.push({
+                type: tool.isError ? "tool.failed" : "tool.completed",
+                sessionId: options.sessionId,
+                toolCallId,
+                ...(tool.isError
+                    ? { error: { message: messageText(tool.content), details: tool.details } }
+                    : { output: toolOutput(tool) }),
+                seq: seq++,
+            });
+        }
+    }
+    if (options.markUnresolvedToolCalls !== false) {
+        for (const [toolCallId, tool] of pendingToolCalls) {
+            if (resolvedToolCalls.has(toolCallId))
+                continue;
+            events.push({
+                type: "tool.failed",
+                sessionId: options.sessionId,
+                toolCallId,
+                error: {
+                    message: "Tool call did not finish. The run may have been interrupted before OpenCandle received a tool result.",
+                    details: { toolName: tool.name, reason: "missing_tool_result" },
+                },
+                seq: seq++,
+            });
+        }
+    }
+    return events;
+}
+function applyOriginalInput(event, originalInput, attachments) {
+    if (event?.type !== "message.completed")
+        return;
+    if (originalInput) {
+        event.content = userMessageContent(event.content, originalInput);
+    }
+    if (attachments.length > 0) {
+        event.attachments = attachments;
+    }
+}
+export function isOriginalInputEntry(entry) {
+    return (entry.type === "custom" &&
+        entry.customType === "opencandle-user-input");
+}
+export function originalInputText(entry) {
+    const data = entry.data;
+    return typeof data?.original === "string" && data.original.trim().length > 0
+        ? data.original
+        : null;
+}
+export function originalInputAttachments(entry) {
+    const data = entry.data;
+    if (!Array.isArray(data?.attachments))
+        return [];
+    return data.attachments
+        .map((attachment) => {
+        if (typeof attachment !== "object" || attachment === null)
+            return null;
+        const kind = String(attachment.kind ?? "").trim();
+        const label = String(attachment.label ?? "").trim();
+        return kind && label ? { kind, label } : null;
+    })
+        .filter((attachment) => attachment != null);
+}
+function customMessageText(content) {
+    if (typeof content === "string")
+        return content;
+    return messageText(content);
+}
+function messageText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.map((part) => (typeof part.text === "string" ? part.text : "")).join("");
+}
+function userMessageContent(content, originalText) {
+    const parts = [{ type: "text", text: originalText ?? messageText(content) }];
+    if (!Array.isArray(content))
+        return parts;
+    for (const part of content) {
+        if (part?.type !== "image")
+            continue;
+        if (typeof part.url === "string") {
+            parts.push({ type: "image", url: part.url, alt: imageAlt(part) });
+            continue;
+        }
+        if (typeof part.data === "string" && typeof part.mimeType === "string") {
+            parts.push({
+                type: "image",
+                url: `data:${part.mimeType};base64,${part.data}`,
+                data: part.data,
+                mimeType: part.mimeType,
+                alt: imageAlt(part),
+            });
+        }
+    }
+    return parts;
+}
+function imageAlt(part) {
+    return typeof part === "object" &&
+        part !== null &&
+        "alt" in part &&
+        typeof part.alt === "string"
+        ? part.alt
+        : undefined;
+}
+function toolOutput(message) {
+    const details = message.details;
+    const source = typeof details === "object" && details !== null && "source" in details
+        ? String(details.source ?? "")
+        : undefined;
+    return {
+        content: message.content,
+        details,
+        isError: message.isError,
+        source,
+    };
+}
+function inputFromDetails(details) {
+    if (typeof details !== "object" || details === null)
+        return undefined;
+    if ("args" in details)
+        return details.args;
+    return undefined;
+}

package/dist/gui/server/gui-session-manager.d.ts

@@ -0,0 +1,2 @@
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+export declare function createInitialGuiSessionManager(cwd: string, sessionDir?: string): SessionManager;

package/dist/gui/server/gui-session-manager.js

@@ -0,0 +1,4 @@
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+export function createInitialGuiSessionManager(cwd, sessionDir) {
+    return SessionManager.create(cwd, sessionDir);
+}

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

@@ -0,0 +1,69 @@
+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 ModelSetupController } from "./model-setup.js";
+import type { QuoteSnapshotStore } from "./quote-snapshot-store.js";
+import { type SessionActionsController } from "./session-actions.js";
+import type { WsHub } from "./ws-hub.js";
+interface GuiHttpRouteOptions {
+    host: string;
+    port: number;
+    webDist: string;
+    role: string;
+    cwd: string;
+    agentDir: string;
+    sessionDir: string;
+    privateApiSessionToken: string;
+    localCoordinatorEndpoint: string;
+    localCoordinatorSecret: string;
+    allowRemotePrivateApi: boolean;
+    syncCurrentWriterLockScope?: () => void;
+    getSession: () => AgentSession;
+    getSessionManager: () => SessionManager;
+    createSessionForManager: (sessionManager: SessionManager) => Promise<{
+        session: AgentSession;
+    }>;
+    wsHub: WsHub;
+    modelSetupController: ModelSetupController;
+    sessionActionsController: SessionActionsController;
+    toolInvokeController: ToolInvokeController;
+    quoteSnapshotStore: QuoteSnapshotStore;
+    localSessionCoordinator?: LocalSessionCoordinator;
+}
+export interface ChatRunImageInput {
+    data: string;
+    mimeType: string;
+}
+export type ChatRunAttachmentInput = {
+    kind: "portfolio";
+    id?: string;
+} | {
+    kind: "watchlist";
+    id: string;
+} | {
+    kind: "report";
+    id: string;
+};
+export interface ParsedChatRunBody {
+    prompt: string;
+    images: ChatRunImageInput[];
+    attachments: ChatRunAttachmentInput[];
+}
+type ChatRunParseResult = {
+    ok: true;
+    value: ParsedChatRunBody;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function createHttpRequestHandler(options: GuiHttpRouteOptions): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+export declare function canProxyChatRunToCoordinator(runSessionManager: SessionManager): boolean;
+export declare function isModelAuthenticationFailure(error: unknown): boolean;
+export declare function buildSessionBootstrapPayload(options: Pick<GuiHttpRouteOptions, "cwd" | "sessionDir" | "role" | "modelSetupController" | "getSessionManager" | "wsHub">, sessionManager: SessionManager): Promise<Record<string, unknown>>;
+export declare function resolveSessionManagerById(options: Pick<GuiHttpRouteOptions, "cwd" | "sessionDir" | "getSessionManager">, sessionId: string): Promise<SessionManager | null>;
+export declare function sessionIdFromRoute(pathname: string, action: "bootstrap" | "runs"): string;
+export declare function buildChatRunActionEnvelope(body: Record<string, unknown>, sessionId: string): SessionActionEnvelope;
+export declare function parseChatRunBody(body: unknown): ChatRunParseResult;
+export declare function buildDispatchedPrompt(parsed: ParsedChatRunBody): Promise<string>;
+export {};