opencandle 0.11.0 → 0.12.0

package/dist/gui/server/ws-hub.js

@@ -0,0 +1,284 @@
+import { probeProviderStatus } from "../../onboarding/provider-status.js";
+import { getProvider } from "../../onboarding/providers.js";
+import { clearProviderOnboardingEntry, loadOnboardingState, saveOnboardingState, } from "../../onboarding/state.js";
+import { sessionEntriesToChatEvents } from "./chat-event-adapter.js";
+import { getSavedMarketStateSymbols } from "./market-state-api.js";
+import { projectDashboard } from "./projector.js";
+import { listDisplaySessions } from "./session-list.js";
+import { buildCatalog, setToolEnabled } from "./tool-metadata.js";
+import { acceptWebSocket } from "./websocket.js";
+import { readWriterLock, writerLockScopeForSession } from "./writer-lock.js";
+export function createWsHub({ role, lock, cwd, sessionDir, getSession, getSessionManager, backgroundQuoteRefreshes, askUserBridge, modelSetupController, toolInvokeController, sessionActionsController, onClientCountChanged, isTrustedRequest = () => true, acceptWebSocketFn = acceptWebSocket, }) {
+    const clients = new Set();
+    function handleUpgrade(req, socket) {
+        if (req.url !== "/ws") {
+            socket.destroy();
+            return;
+        }
+        if (!isTrustedRequest(req)) {
+            socket.destroy();
+            return;
+        }
+        const client = acceptWebSocketFn(req, socket);
+        clients.add(client);
+        client.onClose(() => {
+            clients.delete(client);
+            onClientCountChanged();
+        });
+        client.onMessage((message) => void handleClientMessage(client, message));
+        sendBoot(client);
+        onClientCountChanged();
+    }
+    async function handleClientMessage(client, message) {
+        const data = asRecord(message);
+        try {
+            switch (data.type) {
+                case "chat.prompt":
+                    // Legacy implicit-active-session mutation; parity with the HTTP
+                    // route's 410. Chat runs go through the session-addressed API.
+                    throw new Error("Legacy active-session chat prompts are no longer supported. Use the session-addressed chat-run API.");
+                case "ask_user.answer":
+                    await sessionActionsController.handleAskUserAnswer(String(data.id ?? ""), data.answer, {
+                        actionId: String(data.actionId ?? ""),
+                        sessionId: String(data.sessionId ?? ""),
+                        source: "browser",
+                    });
+                    break;
+                case "ask_user.cancel":
+                    await sessionActionsController.handleAskUserCancel(String(data.id ?? ""), {
+                        actionId: String(data.actionId ?? ""),
+                        sessionId: String(data.sessionId ?? ""),
+                        source: "browser",
+                    });
+                    break;
+                case "tool.invoke":
+                    await toolInvokeController.handleToolInvokeMessage(client, data);
+                    break;
+                case "tool.enabled":
+                    if (role !== "writer")
+                        throw new Error("Read-only follower mode");
+                    setToolEnabled(String(data.toolName), Boolean(data.enabled));
+                    broadcast({ type: "catalog", catalog: buildCatalog(), restartRequired: true });
+                    break;
+                case "catalog.refresh":
+                    client.send({ type: "catalog", catalog: buildCatalog() });
+                    break;
+                case "model.setup.refresh":
+                    getSession().modelRegistry.refresh();
+                    broadcastModelSetup();
+                    break;
+                case "model.setup.save_api_key":
+                    await modelSetupController.handleSaveModelApiKey(String(data.provider ?? ""), String(data.apiKey ?? ""));
+                    broadcastModelSetup();
+                    break;
+                case "model.setup.select_model":
+                    await modelSetupController.handleSelectModel(String(data.provider ?? ""), String(data.modelId ?? ""));
+                    broadcastModelSetup();
+                    break;
+                case "provider.save_api_key":
+                    await modelSetupController.handleSaveProviderApiKey(String(data.providerId ?? ""), String(data.apiKey ?? ""));
+                    broadcast({ type: "catalog", catalog: buildCatalog() });
+                    break;
+                case "provider.status.check": {
+                    const providerId = String(data.providerId ?? "");
+                    getProvider(providerId);
+                    const mode = data.mode === "session" ? "session" : "install";
+                    if (data.reenable === true) {
+                        saveOnboardingState(clearProviderOnboardingEntry(loadOnboardingState(), providerId));
+                        broadcast({ type: "catalog", catalog: buildCatalog() });
+                    }
+                    const status = await probeProviderStatus(providerId, { mode, force: true });
+                    client.send({ type: "provider.status", providerId, status });
+                    break;
+                }
+                case "session.new":
+                    await sessionActionsController.handleNewSession();
+                    sendBoot(client);
+                    broadcastState();
+                    broadcastSessions();
+                    break;
+                case "session.open":
+                    await sessionActionsController.handleOpenSession(String(data.path ?? ""));
+                    sendBoot(client);
+                    broadcastState();
+                    broadcastSessions();
+                    break;
+                case "session.rename":
+                    await sessionActionsController.handleRenameSession(String(data.path ?? ""), String(data.name ?? ""));
+                    broadcastState();
+                    broadcastSessions();
+                    break;
+                case "session.delete":
+                    await sessionActionsController.handleDeleteSession(client, String(data.path ?? ""));
+                    break;
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            client.send({
+                type: "error",
+                message: errorMessage === "Read-only follower mode"
+                    ? "OpenCandle is reconnecting to this session."
+                    : errorMessage,
+            });
+        }
+    }
+    function getClientCount() {
+        return clients.size;
+    }
+    function closeClients() {
+        for (const client of clients)
+            client.close();
+        clients.clear();
+    }
+    function sendBoot(client) {
+        const snapshot = buildStateSnapshot();
+        const sessionManager = getSessionManager();
+        client.send({
+            type: "boot",
+            role,
+            lock: publicWriterLock(lock),
+            sessionId: sessionManager.getSessionId(),
+            coordination: coordinationStateForSession(sessionManager, role, lock),
+            catalog: buildCatalog(),
+            modelSetup: modelSetupController.buildCurrentModelSetupState(),
+            askUserPrompts: askUserBridge.getPrompts(),
+        });
+        client.send({
+            type: "state.snapshot",
+            ...snapshot,
+        });
+        void listDisplaySessions(cwd, sessionDir).then((sessions) => client.send({ type: "sessions", sessions }));
+    }
+    async function buildBootstrapPayload() {
+        const sessionManager = getSessionManager();
+        return {
+            role,
+            sessionId: sessionManager.getSessionId(),
+            coordination: coordinationStateForSession(sessionManager, role, lock),
+            catalog: buildCatalog(),
+            modelSetup: modelSetupController.buildCurrentModelSetupState(),
+            askUserPrompts: askUserBridge.getPrompts(),
+            sessions: await listDisplaySessions(cwd, sessionDir),
+            snapshot: buildStateSnapshot(),
+        };
+    }
+    function broadcastModelSetup() {
+        broadcast({
+            type: "model.setup",
+            modelSetup: modelSetupController.buildCurrentModelSetupState(),
+        });
+    }
+    function broadcastState() {
+        broadcast({
+            type: "state.snapshot",
+            ...buildStateSnapshot(),
+        });
+    }
+    function broadcastSessionSnapshot(sessionManager) {
+        broadcast({
+            type: "session.snapshot",
+            ...buildSnapshotForSession(sessionManager),
+        });
+    }
+    function buildStateSnapshot() {
+        const sessionManager = getSessionManager();
+        const sessionId = sessionManager.getSessionId();
+        const entries = sessionManager.getEntries();
+        return {
+            sessionId,
+            state: projectDashboard(backgroundQuoteRefreshes.withEntries(entries), sessionId, getSavedMarketStateSymbols()),
+            entries,
+            events: currentChatEvents(entries),
+            // Ownership can change mid-run (e.g. a TUI takes over the session), so
+            // snapshots re-derive coordination instead of relying on boot state.
+            coordination: coordinationStateForSession(sessionManager, role, lock),
+        };
+    }
+    function buildSnapshotForSession(sessionManager) {
+        const sessionId = sessionManager.getSessionId();
+        const entries = sessionManager.getEntries();
+        return {
+            sessionId,
+            state: projectDashboard(backgroundQuoteRefreshes.withEntries(entries), sessionId, getSavedMarketStateSymbols()),
+            entries,
+            events: sessionEntriesToChatEvents(entries, {
+                sessionId,
+                title: sessionManager.getSessionName(),
+            }),
+        };
+    }
+    function currentChatEvents(entries = getSessionManager().getEntries()) {
+        const sessionManager = getSessionManager();
+        const session = getSession();
+        return sessionEntriesToChatEvents(entries, {
+            sessionId: sessionManager.getSessionId(),
+            title: sessionManager.getSessionName(),
+            markUnresolvedToolCalls: !(session.isStreaming || session.pendingMessageCount > 0),
+        });
+    }
+    function broadcastSessions() {
+        void listDisplaySessions(cwd, sessionDir).then((sessions) => broadcast({ type: "sessions", sessions }));
+    }
+    function broadcast(message) {
+        for (const client of clients)
+            client.send(message);
+    }
+    function subscribeToSessionEvents() {
+        return getSession().subscribe((event) => {
+            broadcast({ type: "session.event", event });
+            broadcastState();
+        });
+    }
+    return {
+        handleUpgrade,
+        getClientCount,
+        closeClients,
+        sendBoot,
+        buildBootstrapPayload,
+        broadcast,
+        broadcastModelSetup,
+        broadcastState,
+        broadcastSessionSnapshot,
+        broadcastSessions,
+        buildStateSnapshot,
+        currentChatEvents,
+        subscribeToSessionEvents,
+    };
+}
+function coordinationStateForSession(sessionManager, role, fallbackLock) {
+    let sessionLock = fallbackLock;
+    try {
+        sessionLock = readWriterLock(writerLockScopeForSession(sessionManager)) ?? fallbackLock;
+    }
+    catch {
+        sessionLock = fallbackLock;
+    }
+    const sessionId = sessionManager.getSessionId();
+    const publicLock = asRecord(publicWriterLock(sessionLock));
+    const ownedByThisProcess = publicLock.pid === process.pid;
+    const status = role === "writer" && (!publicLock.pid || ownedByThisProcess)
+        ? "ready"
+        : role === "connecting"
+            ? "connecting"
+            : role === "disconnected"
+                ? "reconnecting"
+                : "syncing";
+    return {
+        sessionId,
+        status,
+        ...(typeof publicLock.processKind === "string" ? { ownerKind: publicLock.processKind } : {}),
+    };
+}
+function publicWriterLock(lock) {
+    const record = asRecord(lock);
+    if (Object.keys(record).length === 0)
+        return lock;
+    const { coordinatorSecret: _coordinatorSecret, ...publicLock } = record;
+    return publicLock;
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}

package/dist/gui/shared/chat-events.d.ts

@@ -0,0 +1,174 @@
+export type ChatRole = "user" | "assistant" | "system";
+export interface MessageTextContent {
+    type: "text";
+    text: string;
+}
+export interface MessageToolContent {
+    type: "tool";
+    toolCallId: string;
+}
+export interface MessageImageContent {
+    type: "image";
+    url?: string;
+    data?: string;
+    mimeType?: string;
+    alt?: string;
+}
+export type MessageContent = MessageTextContent | MessageToolContent | MessageImageContent;
+export interface MessageAttachmentChip {
+    kind: string;
+    label: string;
+}
+export interface ToolOutput {
+    content: Array<{
+        type: string;
+        text?: string;
+        data?: string;
+        mimeType?: string;
+    }>;
+    details?: unknown;
+    isError?: boolean;
+    source?: string;
+}
+export interface ToolError {
+    message: string;
+    code?: string;
+    details?: unknown;
+}
+export interface RunError {
+    message: string;
+    code?: string;
+    details?: unknown;
+}
+export interface Usage {
+    input?: number;
+    output?: number;
+    totalTokens?: number;
+    cost?: unknown;
+}
+interface ChatEventBase {
+    sessionId: string;
+    seq: number;
+}
+interface RunScopedChatEventBase extends ChatEventBase {
+    runId: string;
+}
+export type ChatEvent = ({
+    type: "run.started";
+} & RunScopedChatEventBase) | ({
+    type: "thinking.delta";
+    text: string;
+} & RunScopedChatEventBase) | ({
+    type: "thinking.completed";
+    text?: string;
+} & RunScopedChatEventBase) | ({
+    type: "message.created";
+    messageId: string;
+    role: ChatRole;
+    runId?: string;
+} & ChatEventBase) | ({
+    type: "message.delta";
+    messageId: string;
+    text: string;
+    runId?: string;
+} & ChatEventBase) | ({
+    type: "message.completed";
+    messageId: string;
+    content: MessageContent[];
+    attachments?: MessageAttachmentChip[];
+    runId?: string;
+} & ChatEventBase) | ({
+    type: "custom.message";
+    messageId: string;
+    customType: string;
+    content: MessageContent[];
+    details?: unknown;
+} & ChatEventBase) | ({
+    type: "tool.started";
+    toolCallId: string;
+    messageId: string;
+    name: string;
+    input: unknown;
+    runId?: string;
+} & ChatEventBase) | ({
+    type: "tool.delta";
+    toolCallId: string;
+    chunk: unknown;
+    runId?: string;
+} & ChatEventBase) | ({
+    type: "tool.completed";
+    toolCallId: string;
+    output: ToolOutput;
+    runId?: string;
+} & ChatEventBase) | ({
+    type: "tool.failed";
+    toolCallId: string;
+    error: ToolError;
+    runId?: string;
+} & ChatEventBase) | ({
+    type: "run.completed";
+    usage?: Usage;
+} & RunScopedChatEventBase) | ({
+    type: "run.failed";
+    error: RunError;
+} & RunScopedChatEventBase) | ({
+    type: "session.updated";
+    title?: string;
+    updatedAt: string;
+} & ChatEventBase);
+export interface RenderMessage {
+    id: string;
+    sessionId?: string;
+    role: ChatRole;
+    status: "streaming" | "completed";
+    content: MessageContent[];
+    text: string;
+    attachments?: MessageAttachmentChip[];
+    customType?: string;
+    details?: unknown;
+}
+export interface RenderToolCall {
+    id: string;
+    sessionId?: string;
+    messageId: string;
+    name: string;
+    input: unknown;
+    status: "queued" | "running" | "completed" | "failed";
+    chunks: unknown[];
+    output?: ToolOutput;
+    error?: ToolError;
+}
+export interface RenderThinking {
+    runId: string;
+    sessionId?: string;
+    status: "streaming" | "completed";
+    text: string;
+}
+export interface ChatRunState {
+    id: string;
+    sessionId?: string;
+    status: "running" | "completed" | "failed";
+    usage?: Usage;
+    error?: RunError;
+}
+export interface ChatRenderState {
+    lastSeq: number;
+    seenSeq: Set<string>;
+    lastSeqBySession: Map<string, number>;
+    messages: RenderMessage[];
+    messageById: Map<string, RenderMessage>;
+    tools: Map<string, RenderToolCall>;
+    runs: Map<string, ChatRunState>;
+    thinking: Map<string, RenderThinking>;
+    session?: {
+        id: string;
+        title?: string;
+        updatedAt?: string;
+    };
+    gaps: Array<{
+        expected: number;
+        received: number;
+    }>;
+}
+export declare function createChatRenderState(): ChatRenderState;
+export {};

package/dist/gui/shared/chat-events.js

@@ -0,0 +1,13 @@
+export function createChatRenderState() {
+    return {
+        lastSeq: 0,
+        seenSeq: new Set(),
+        lastSeqBySession: new Map(),
+        messages: [],
+        messageById: new Map(),
+        tools: new Map(),
+        runs: new Map(),
+        thinking: new Map(),
+        gaps: [],
+    };
+}

package/dist/gui/shared/event-reducer.d.ts

@@ -0,0 +1,3 @@
+import { type ChatEvent, type ChatRenderState } from "./chat-events.js";
+export declare function reduceChatEvents(events: ChatEvent[]): ChatRenderState;
+export declare function applyChatEvent(state: ChatRenderState, event: ChatEvent): ChatRenderState;

package/dist/gui/shared/event-reducer.js

@@ -0,0 +1,187 @@
+import { createChatRenderState, } from "./chat-events.js";
+export function reduceChatEvents(events) {
+    return [...events]
+        .sort((a, b) => (a.sessionId === b.sessionId ? a.seq - b.seq : 0))
+        .reduce((state, event) => applyChatEvent(state, event), createChatRenderState());
+}
+export function applyChatEvent(state, event) {
+    const eventKey = `${event.sessionId}:${event.seq}`;
+    if (state.seenSeq.has(eventKey))
+        return state;
+    const next = cloneState(state);
+    const sessionLastSeq = next.lastSeqBySession.get(event.sessionId) ?? 0;
+    if (event.seq > sessionLastSeq + 1 && sessionLastSeq !== 0) {
+        next.gaps.push({ expected: sessionLastSeq + 1, received: event.seq });
+    }
+    next.seenSeq.add(eventKey);
+    next.lastSeqBySession.set(event.sessionId, Math.max(sessionLastSeq, event.seq));
+    next.lastSeq = Math.max(next.lastSeq, event.seq);
+    switch (event.type) {
+        case "run.started":
+            next.runs.set(scopedId(event.sessionId, event.runId), {
+                id: event.runId,
+                sessionId: event.sessionId,
+                status: "running",
+            });
+            next.session = { ...next.session, id: event.sessionId };
+            break;
+        case "thinking.delta": {
+            const thinking = ensureThinking(next, event.sessionId, event.runId);
+            thinking.status = "streaming";
+            thinking.text += event.text;
+            break;
+        }
+        case "thinking.completed": {
+            const thinking = ensureThinking(next, event.sessionId, event.runId);
+            thinking.status = "completed";
+            if (event.text !== undefined)
+                thinking.text = event.text;
+            break;
+        }
+        case "message.created":
+            ensureMessage(next, event.sessionId, event.messageId, event.role);
+            break;
+        case "message.delta": {
+            const message = ensureMessage(next, event.sessionId, event.messageId, "assistant");
+            message.status = "streaming";
+            message.text += event.text;
+            message.content = [{ type: "text", text: message.text }];
+            break;
+        }
+        case "message.completed": {
+            const message = ensureMessage(next, event.sessionId, event.messageId, "assistant");
+            message.status = "completed";
+            message.content = event.content;
+            message.text = contentText(event.content);
+            message.attachments = event.attachments;
+            break;
+        }
+        case "custom.message": {
+            const message = ensureMessage(next, event.sessionId, event.messageId, "assistant");
+            message.status = "completed";
+            message.content = event.content;
+            message.text = contentText(event.content);
+            message.customType = event.customType;
+            message.details = event.details;
+            break;
+        }
+        case "tool.started":
+            ensureMessage(next, event.sessionId, event.messageId, "assistant");
+            next.tools.set(scopedId(event.sessionId, event.toolCallId), {
+                id: event.toolCallId,
+                sessionId: event.sessionId,
+                messageId: event.messageId,
+                name: event.name,
+                input: event.input,
+                status: "running",
+                chunks: [],
+            });
+            break;
+        case "tool.delta": {
+            const tool = next.tools.get(scopedId(event.sessionId, event.toolCallId));
+            if (tool)
+                tool.chunks.push(event.chunk);
+            break;
+        }
+        case "tool.completed": {
+            const tool = next.tools.get(scopedId(event.sessionId, event.toolCallId));
+            if (tool) {
+                tool.status = event.output.isError ? "failed" : "completed";
+                tool.output = event.output;
+            }
+            break;
+        }
+        case "tool.failed": {
+            const tool = next.tools.get(scopedId(event.sessionId, event.toolCallId));
+            if (tool) {
+                tool.status = "failed";
+                tool.error = event.error;
+            }
+            break;
+        }
+        case "run.completed": {
+            const run = next.runs.get(scopedId(event.sessionId, event.runId));
+            if (run) {
+                run.status = "completed";
+                run.usage = event.usage;
+            }
+            break;
+        }
+        case "run.failed": {
+            const run = next.runs.get(scopedId(event.sessionId, event.runId));
+            if (run) {
+                run.status = "failed";
+                run.error = event.error;
+            }
+            break;
+        }
+        case "session.updated":
+            next.session = {
+                id: event.sessionId,
+                title: event.title,
+                updatedAt: event.updatedAt,
+            };
+            break;
+    }
+    return next;
+}
+function ensureMessage(state, sessionId, id, role) {
+    const key = scopedId(sessionId, id);
+    const existing = state.messageById.get(key);
+    if (existing)
+        return existing;
+    const message = {
+        id,
+        sessionId,
+        role,
+        status: "streaming",
+        content: [],
+        text: "",
+    };
+    state.messageById.set(key, message);
+    state.messages.push(message);
+    return message;
+}
+function cloneState(state) {
+    const messages = state.messages.map((message) => ({
+        ...message,
+        content: [...message.content],
+    }));
+    const messageById = new Map(messages.map((message) => [scopedId(message.sessionId ?? "", message.id), message]));
+    return {
+        ...state,
+        seenSeq: new Set(state.seenSeq),
+        lastSeqBySession: new Map(state.lastSeqBySession),
+        messages,
+        messageById,
+        tools: new Map([...state.tools].map(([id, tool]) => [
+            id,
+            {
+                ...tool,
+                chunks: [...tool.chunks],
+            },
+        ])),
+        runs: new Map([...state.runs].map(([id, run]) => [id, { ...run }])),
+        thinking: new Map([...state.thinking].map(([id, thinking]) => [id, { ...thinking }])),
+        session: state.session ? { ...state.session } : undefined,
+        gaps: [...state.gaps],
+    };
+}
+function ensureThinking(state, sessionId, runId) {
+    const key = scopedId(sessionId, runId);
+    const existing = state.thinking.get(key);
+    if (existing)
+        return existing;
+    const thinking = { runId, sessionId, status: "streaming", text: "" };
+    state.thinking.set(key, thinking);
+    return thinking;
+}
+function scopedId(sessionId, id) {
+    return `${sessionId ?? ""}::${id}`;
+}
+function contentText(content) {
+    return content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("");
+}

package/dist/index.js

@@ -3,4 +3,3 @@ export { createOpenCandleSession } from "./pi/session.js";
 export { agentToolToPiTool, getOpenCandleToolDefinitions } from "./pi/tool-adapter.js";
 export { registerTools } from "./tool-kit.js";
 export { getAllTools } from "./tools/index.js";
-//# sourceMappingURL=index.js.map

package/dist/infra/cache.d.ts

@@ -5,6 +5,10 @@ export interface StaleResult<T> {
 }
 export declare function runWithStaleMetadata<T>(fn: () => Promise<T>): Promise<{
     value: T;
+    cache?: {
+        status: "cached" | "stale";
+        cachedAt: number;
+    };
     stale?: {
         cachedAt: number;
     };
@@ -35,6 +39,7 @@ export declare const TTL: {
     readonly CRUMB: 900000;
     readonly WEB_SEARCH: 300000;
     readonly FINNHUB_NEWS: 300000;
+    readonly PREDICTION_MARKETS: 300000;
 };
 export declare const STALE_LIMIT: {
     readonly QUOTE: number;
@@ -46,4 +51,5 @@ export declare const STALE_LIMIT: {
     readonly SCREENER: number;
     readonly WEB_SEARCH: 3600000;
     readonly FINNHUB_NEWS: 3600000;
+    readonly PREDICTION_MARKETS: 3600000;
 };