opencandle 0.11.1 → 0.13.0

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

@@ -0,0 +1,388 @@
+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 workflowSteps = workflowStepMetadata(entries);
+    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") {
+            const workflowStep = workflowSteps.get(messageId);
+            if (!workflowStep || workflowStep.preserveUserTurn) {
+                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;
+            }
+            else {
+                lastEntryWasUserMessage = false;
+            }
+            if (workflowStep) {
+                events.push({
+                    type: "custom.message",
+                    sessionId: options.sessionId,
+                    messageId: `workflow-step-${messageId}`,
+                    customType: "opencandle-workflow-step",
+                    content: userMessageContent(message.content, null),
+                    details: workflowStep,
+                    seq: seq++,
+                });
+            }
+            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 workflowStepMetadata(entries) {
+    const groups = [];
+    let activeGroup = null;
+    let pendingOriginalInput = false;
+    let awaitingValidationPrompt = false;
+    for (const entry of entries) {
+        if (isCustomEntry(entry, "opencandle-workflow")) {
+            activeGroup = [];
+            groups.push(activeGroup);
+            pendingOriginalInput = false;
+            awaitingValidationPrompt = false;
+            continue;
+        }
+        if (isOriginalInputEntry(entry)) {
+            if (awaitingValidationPrompt) {
+                activeGroup = null;
+                awaitingValidationPrompt = false;
+            }
+            if (activeGroup)
+                pendingOriginalInput = true;
+            continue;
+        }
+        if (entry.type === "message" && entry.message.role === "user") {
+            if (activeGroup) {
+                const candidate = {
+                    messageId: entry.id,
+                    preserveUserTurn: pendingOriginalInput,
+                };
+                if (awaitingValidationPrompt) {
+                    candidate.stage = "validation";
+                    candidate.label = "Validation and synthesis";
+                }
+                activeGroup.push(candidate);
+                if (awaitingValidationPrompt) {
+                    activeGroup = null;
+                    awaitingValidationPrompt = false;
+                }
+            }
+            pendingOriginalInput = false;
+            continue;
+        }
+        if (isCustomEntry(entry, "opencandle-analyst-step")) {
+            const data = customEntryData(entry);
+            const stage = stringField(data, "stage") ?? "analysis";
+            assignPendingWorkflowSteps(activeGroup, stage, workflowStepLabel(stage, data));
+            continue;
+        }
+        if (isCustomEntry(entry, "opencandle-validation")) {
+            assignPendingWorkflowSteps(activeGroup, "validation", "Validation and synthesis");
+            awaitingValidationPrompt = activeGroup !== null;
+            pendingOriginalInput = false;
+        }
+    }
+    const metadata = new Map();
+    for (const group of groups) {
+        group.forEach((candidate, index) => {
+            metadata.set(candidate.messageId, {
+                label: candidate.label ?? "Workflow step",
+                stage: candidate.stage ?? "workflow",
+                step: index + 1,
+                total: group.length,
+                preserveUserTurn: candidate.preserveUserTurn,
+            });
+        });
+    }
+    return metadata;
+}
+function assignPendingWorkflowSteps(group, stage, label) {
+    if (!group)
+        return;
+    for (let index = group.length - 1; index >= 0; index -= 1) {
+        const candidate = group[index];
+        if (candidate.stage)
+            continue;
+        candidate.stage = stage;
+        candidate.label = label;
+        return;
+    }
+}
+function workflowStepLabel(stage, data) {
+    const role = stringField(data, "role");
+    if (stage.startsWith("analyst_")) {
+        return `${sentenceCase(role ?? stage.slice("analyst_".length))} analyst`;
+    }
+    if (stage === "debate_bull")
+        return "Bull researcher";
+    if (stage === "debate_bear")
+        return "Bear researcher";
+    if (stage === "debate_rebuttal")
+        return "Debate rebuttal";
+    return sentenceCase(stage.replaceAll("_", " "));
+}
+function sentenceCase(value) {
+    const normalized = value.trim().toLowerCase();
+    return normalized ? `${normalized[0].toUpperCase()}${normalized.slice(1)}` : "Workflow step";
+}
+function isCustomEntry(entry, customType) {
+    return entry.type === "custom" && entry.customType === customType;
+}
+function customEntryData(entry) {
+    const data = entry.data;
+    return typeof data === "object" && data !== null ? data : {};
+}
+function stringField(data, field) {
+    const value = data[field];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+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/history-snapshot-store.d.ts

@@ -0,0 +1,8 @@
+export declare class HistorySnapshotStore<T> {
+    private readonly maxAgeMs;
+    private readonly now;
+    private readonly entries;
+    constructor(maxAgeMs?: number, now?: () => number);
+    get(key: string, build: () => Promise<T>): Promise<T>;
+    clear(): void;
+}

package/dist/gui/server/history-snapshot-store.js

@@ -0,0 +1,43 @@
+export class HistorySnapshotStore {
+    maxAgeMs;
+    now;
+    entries = new Map();
+    constructor(maxAgeMs = 60_000, now = Date.now) {
+        this.maxAgeMs = maxAgeMs;
+        this.now = now;
+    }
+    get(key, build) {
+        const existing = this.entries.get(key);
+        if (existing?.hasValue && this.now() - existing.fetchedAtMs < this.maxAgeMs) {
+            return Promise.resolve(existing.value);
+        }
+        if (existing?.inFlight)
+            return existing.inFlight;
+        const entry = existing ??
+            { hasValue: false, fetchedAtMs: 0, inFlight: null };
+        let buildPromise;
+        try {
+            buildPromise = build();
+        }
+        catch (error) {
+            buildPromise = Promise.reject(error);
+        }
+        const inFlight = buildPromise
+            .then((value) => {
+            entry.value = value;
+            entry.hasValue = true;
+            entry.fetchedAtMs = this.now();
+            return value;
+        })
+            .finally(() => {
+            if (entry.inFlight === inFlight)
+                entry.inFlight = null;
+        });
+        entry.inFlight = inFlight;
+        this.entries.set(key, entry);
+        return inFlight;
+    }
+    clear() {
+        this.entries.clear();
+    }
+}

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

@@ -0,0 +1,71 @@
+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 { MarketIndicesSnapshotStore } from "./market-indices-snapshot-store.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;
+    indicesSnapshotStore: MarketIndicesSnapshotStore;
+    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 {};