opencandle 0.11.1 → 0.12.0

package/gui/server/session-entry-wait.ts

@@ -1,179 +0,0 @@
-import type { SessionEntry } from "@earendil-works/pi-coding-agent";
-
-export interface WaitForEntryCountOptions {
-  timeoutMs?: number;
-  intervalMs?: number;
-}
-
-export interface WaitForSessionTurnSettlementOptions extends WaitForEntryCountOptions {
-  idleGraceMs?: number;
-}
-
-export interface SessionRunStatus {
-  isStreaming: boolean;
-  pendingMessageCount: number;
-  /**
-   * Monotonic activity signal (e.g. a session-event counter). A single long
-   * model generation keeps isStreaming/pendingMessageCount frozen for its
-   * whole duration; this token is what distinguishes it from a hung run.
-   */
-  progressToken?: number;
-}
-
-export interface UnresolvedToolCall {
-  id: string;
-  name: string;
-}
-
-export async function waitForEntryCount(
-  getCount: () => number,
-  previousCount: number,
-  options: WaitForEntryCountOptions = {},
-): Promise<void> {
-  const timeoutMs = options.timeoutMs ?? 2_000;
-  const intervalMs = options.intervalMs ?? 25;
-  const deadline = Date.now() + timeoutMs;
-
-  while (getCount() <= previousCount && Date.now() < deadline) {
-    await delay(intervalMs);
-  }
-  if (getCount() <= previousCount) {
-    throw new Error("Timed out waiting for a new session entry");
-  }
-}
-
-export async function waitForNewEntryId(
-  getIds: () => string[],
-  previousIds: Set<string>,
-  options: WaitForEntryCountOptions = {},
-): Promise<void> {
-  const timeoutMs = options.timeoutMs ?? 2_000;
-  const intervalMs = options.intervalMs ?? 25;
-  const deadline = Date.now() + timeoutMs;
-
-  while (!getIds().some((id) => !previousIds.has(id)) && Date.now() < deadline) {
-    await delay(intervalMs);
-  }
-  if (!getIds().some((id) => !previousIds.has(id))) {
-    throw new Error("Timed out waiting for a new session entry");
-  }
-}
-
-export async function waitForSessionTurnSettlement(
-  getStatus: () => SessionRunStatus,
-  options: WaitForSessionTurnSettlementOptions = {},
-): Promise<void> {
-  const timeoutMs = options.timeoutMs ?? 120_000;
-  const intervalMs = options.intervalMs ?? 25;
-  const idleGraceMs = options.idleGraceMs ?? 250;
-  // timeoutMs bounds STALL, not total runtime: a live workflow run (e.g.
-  // /analyze) stays active for minutes while its status keeps changing, and
-  // capping total runtime failed those runs mid-workflow with
-  // "Timed out waiting for the session turn to settle". A hung session stops
-  // changing status entirely, which is what the deadline must catch.
-  let lastProgressAt = Date.now();
-  let lastSignature: string | undefined;
-  let idleSince: number | undefined;
-
-  while (true) {
-    const status = getStatus();
-    const signature = `${status.isStreaming}:${status.pendingMessageCount}:${status.progressToken ?? 0}`;
-    if (signature !== lastSignature) {
-      lastSignature = signature;
-      lastProgressAt = Date.now();
-    }
-    const active = status.isStreaming || status.pendingMessageCount > 0;
-
-    if (active) {
-      idleSince = undefined;
-      if (Date.now() - lastProgressAt >= timeoutMs) {
-        throw new Error("Timed out waiting for the session turn to settle");
-      }
-      await delay(intervalMs);
-      continue;
-    }
-
-    idleSince ??= Date.now();
-    if (Date.now() - idleSince >= idleGraceMs) {
-      return;
-    }
-
-    await delay(intervalMs);
-  }
-}
-
-export function findUnresolvedToolCalls(entries: SessionEntry[]): UnresolvedToolCall[] {
-  const latestAssistantIndex = latestAssistantToolUseIndex(entries);
-  if (latestAssistantIndex === -1) return [];
-
-  const assistant = asMessage(entries[latestAssistantIndex]);
-  const calls = toolCallsFromContent(assistant?.content);
-  if (calls.length === 0) return [];
-
-  const resolved = new Set<string>();
-  for (const entry of entries.slice(latestAssistantIndex + 1)) {
-    const message = asMessage(entry);
-    if (message?.role !== "toolResult") continue;
-    const toolCallId = typeof message.toolCallId === "string" ? message.toolCallId : "";
-    if (toolCallId) resolved.add(toolCallId);
-  }
-
-  return calls.filter((call) => !resolved.has(call.id));
-}
-
-export async function waitForResolvedToolCalls(
-  getEntries: () => SessionEntry[],
-  options: WaitForEntryCountOptions = {},
-): Promise<void> {
-  const timeoutMs = options.timeoutMs ?? 120_000;
-  const intervalMs = options.intervalMs ?? 25;
-  const deadline = Date.now() + timeoutMs;
-
-  while (Date.now() < deadline) {
-    if (findUnresolvedToolCalls(getEntries()).length === 0) return;
-    await delay(intervalMs);
-  }
-
-  const unresolved = findUnresolvedToolCalls(getEntries());
-  if (unresolved.length > 0) {
-    throw new Error(
-      `Timed out waiting for tool results: ${unresolved.map((call) => call.name).join(", ")}`,
-    );
-  }
-}
-
-function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function latestAssistantToolUseIndex(entries: SessionEntry[]): number {
-  for (let index = entries.length - 1; index >= 0; index--) {
-    const message = asMessage(entries[index]);
-    if (message?.role === "assistant") {
-      if (toolCallsFromContent(message.content).length > 0) return index;
-      if (message.stopReason === "stop") return -1;
-    }
-    if (message?.role === "user") return -1;
-  }
-  return -1;
-}
-
-function asMessage(entry: SessionEntry | undefined): Record<string, unknown> | undefined {
-  if (entry?.type !== "message") return undefined;
-  const message = (entry as { message?: unknown }).message;
-  return typeof message === "object" && message !== null && !Array.isArray(message)
-    ? (message as Record<string, unknown>)
-    : undefined;
-}
-
-function toolCallsFromContent(content: unknown): UnresolvedToolCall[] {
-  if (!Array.isArray(content)) return [];
-  return content.flatMap((part): UnresolvedToolCall[] => {
-    if (typeof part !== "object" || part === null || Array.isArray(part)) return [];
-    const record = part as Record<string, unknown>;
-    if (record.type !== "toolCall") return [];
-    const id = typeof record.id === "string" ? record.id : "";
-    const name = typeof record.name === "string" ? record.name : "tool";
-    return id ? [{ id, name }] : [];
-  });
-}

package/gui/server/shutdown.ts

@@ -1,47 +0,0 @@
-import type { Server } from "node:http";
-
-type Cleanup = () => void | Promise<void>;
-
-export interface GracefulShutdownOptions {
-  server: Server;
-  cleanup: Cleanup;
-  exit: (code: number) => void;
-  timeoutMs?: number;
-}
-
-export function createGracefulShutdown({
-  server,
-  cleanup,
-  exit,
-  timeoutMs = 1000,
-}: GracefulShutdownOptions): () => void {
-  let shuttingDown = false;
-  let exited = false;
-
-  const finish = () => {
-    if (exited) return;
-    exited = true;
-    exit(0);
-  };
-
-  return () => {
-    if (shuttingDown) return;
-    shuttingDown = true;
-
-    const timeout = setTimeout(() => {
-      server.closeAllConnections?.();
-      finish();
-    }, timeoutMs);
-    timeout.unref?.();
-
-    void Promise.resolve()
-      .then(cleanup)
-      .catch(() => undefined)
-      .finally(() => {
-        server.close(() => {
-          clearTimeout(timeout);
-          finish();
-        });
-      });
-  };
-}

package/gui/server/tool-invoke-ack.ts

@@ -1,49 +0,0 @@
-import type { InvokeToolResult } from "./invoke-tool.js";
-
-export interface ToolInvokeAckMessage {
-  type: "tool.invoke.result";
-  requestId: string;
-  ok: boolean;
-  toolName: string;
-  result?: {
-    toolCallId: string;
-    content: InvokeToolResult["result"]["content"];
-    details: unknown;
-    isError: boolean;
-  };
-  error?: {
-    message: string;
-  };
-}
-
-export function buildToolInvokeAckMessage(
-  requestId: string,
-  toolName: string,
-  invocation: InvokeToolResult,
-): ToolInvokeAckMessage {
-  const message: ToolInvokeAckMessage = {
-    type: "tool.invoke.result",
-    requestId,
-    ok: !invocation.isError,
-    toolName,
-    result: {
-      toolCallId: invocation.toolCallId,
-      content: invocation.result.content,
-      details: invocation.result.details,
-      isError: invocation.isError,
-    },
-  };
-  if (invocation.isError) {
-    message.error = { message: toolResultMessage(invocation) };
-  }
-  return message;
-}
-
-function toolResultMessage(invocation: InvokeToolResult): string {
-  for (const item of invocation.result.content) {
-    if (item?.type === "text" && typeof item.text === "string" && item.text.trim()) {
-      return item.text.trim();
-    }
-  }
-  return `${invocation.toolCallId} failed`;
-}

package/gui/server/tool-metadata.ts

@@ -1,167 +0,0 @@
-import { getOpenCandleToolDefinitions } from "../../src/index.js";
-import { getAllDefaults, setDefault } from "../../src/memory/tool-defaults.js";
-import {
-  getCredential,
-  isApiKeyProvider,
-  isExternalToolProvider,
-  isPublicHttpProvider,
-  PROVIDERS,
-  type ProviderDescriptor,
-} from "../../src/onboarding/providers.js";
-import { loadOnboardingState, type OnboardingState } from "../../src/onboarding/state.js";
-
-const WORKFLOWS = [
-  {
-    id: "comprehensive_analysis",
-    name: "Comprehensive Analysis",
-    description: "Run the multi-analyst stock analysis workflow.",
-    prompt: "/analyze {symbol}",
-    slots: [{ name: "symbol", label: "Symbol", type: "text" }],
-  },
-  {
-    id: "portfolio_builder",
-    name: "Portfolio Builder",
-    description: "Build a diversified portfolio from goals and constraints.",
-    prompt: "Build me a portfolio for {objective}",
-    slots: [{ name: "objective", label: "Objective", type: "text" }],
-  },
-  {
-    id: "options_screener",
-    name: "Options Screener",
-    description: "Screen option chains for a target symbol.",
-    prompt: "Screen options for {symbol}",
-    slots: [{ name: "symbol", label: "Symbol", type: "text" }],
-  },
-  {
-    id: "compare_assets",
-    name: "Compare Assets",
-    description: "Compare two or more assets side by side.",
-    prompt: "Compare {symbols}",
-    slots: [{ name: "symbols", label: "Symbols", type: "text" }],
-  },
-];
-
-export function buildCatalog() {
-  const defaults = getAllDefaults();
-  const onboardingState = loadOnboardingState();
-  const tools = getOpenCandleToolDefinitions().map((tool) => ({
-    name: tool.name,
-    label: tool.label,
-    description: tool.description,
-    parameters: tool.parameters,
-    domain: inferDomain(tool.name),
-    enabled: defaults.get(tool.name)?.__enabled !== false,
-    defaults: defaults.get(tool.name) ?? {},
-  }));
-
-  return {
-    tools,
-    workflows: WORKFLOWS,
-    providers: PROVIDERS.map((provider) => serializeProvider(provider, onboardingState)),
-  };
-}
-
-function serializeProvider(provider: ProviderDescriptor, onboardingState: OnboardingState) {
-  const common = {
-    id: provider.id,
-    kind: provider.kind,
-    displayName: provider.displayName,
-    category: provider.category,
-    tier: provider.tier,
-    aliases: provider.aliases,
-    unlocks: provider.unlocks,
-    fallbackDescription: provider.fallbackDescription,
-    instructionsHint: provider.instructionsHint,
-  };
-
-  if (isApiKeyProvider(provider)) {
-    // Never serialize the credential value: this payload reaches the browser DOM.
-    const credential = getCredential(provider.id);
-    const source = credential.source;
-    return {
-      ...common,
-      source,
-      configured: source !== "absent",
-      maskedKeyHint: credential.value ? `…${credential.value.slice(-4)}` : undefined,
-      status: source,
-      signupUrl: provider.signupUrl,
-      freeTier: provider.freeTier,
-      envVar: provider.envVar,
-    };
-  }
-
-  if (isExternalToolProvider(provider)) {
-    if (onboardingState.providers[provider.id]?.status === "never_ask") {
-      return {
-        ...common,
-        status: "skipped",
-        statusDetail: {
-          providerId: provider.id,
-          kind: "external-tool",
-          mode: "install",
-          state: "skipped",
-          installCmd: provider.installCmd,
-          message: `Skipped by user preference; run opencandle doctor --enable ${provider.id} to re-enable.`,
-          checkedAt: new Date().toISOString(),
-          cacheHit: false,
-        },
-        binary: provider.binary,
-        installCmd: provider.installCmd,
-        sessionSource: provider.sessionSource,
-        supportedBrowsers: provider.supportedBrowsers,
-      };
-    }
-    return {
-      ...common,
-      status: "unknown",
-      binary: provider.binary,
-      installCmd: provider.installCmd,
-      sessionSource: provider.sessionSource,
-      supportedBrowsers: provider.supportedBrowsers,
-    };
-  }
-
-  if (isPublicHttpProvider(provider)) {
-    return {
-      ...common,
-      status: "unknown",
-      probeUrl: provider.probeUrl,
-    };
-  }
-
-  const exhaustive: never = provider;
-  return exhaustive;
-}
-
-export function setToolEnabled(toolName: string, enabled: boolean): void {
-  setDefault(toolName, "__enabled", enabled);
-}
-
-function inferDomain(toolName: string): string {
-  if (toolName.includes("option")) return "options";
-  if (
-    toolName.includes("portfolio") ||
-    toolName.includes("risk") ||
-    toolName.includes("correlation")
-  )
-    return "portfolio";
-  if (
-    toolName.includes("sentiment") ||
-    toolName.includes("reddit") ||
-    toolName.includes("twitter") ||
-    toolName.includes("web")
-  )
-    return "sentiment";
-  if (toolName.includes("economic") || toolName.includes("fear")) return "macro";
-  if (toolName.includes("technical") || toolName.includes("backtest")) return "technical";
-  if (
-    toolName.includes("company") ||
-    toolName.includes("financial") ||
-    toolName.includes("earnings") ||
-    toolName.includes("dcf") ||
-    toolName.includes("sec")
-  )
-    return "fundamentals";
-  if (toolName.includes("ask_user") || toolName.includes("login")) return "interaction";
-  return "market";
-}

package/gui/server/websocket.ts

@@ -1,138 +0,0 @@
-import { createHash } from "node:crypto";
-import type { IncomingMessage } from "node:http";
-import type { Duplex } from "node:stream";
-
-export interface WsClient {
-  send(data: unknown): void;
-  close(): void;
-  onMessage(handler: (data: unknown) => void): void;
-  onClose(handler: () => void): void;
-}
-
-export function acceptWebSocket(req: IncomingMessage, socket: Duplex): WsClient {
-  const key = req.headers["sec-websocket-key"];
-  if (typeof key !== "string") {
-    socket.destroy();
-    throw new Error("Missing Sec-WebSocket-Key");
-  }
-
-  const accept = createHash("sha1")
-    .update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`)
-    .digest("base64");
-
-  socket.write(
-    [
-      "HTTP/1.1 101 Switching Protocols",
-      "Upgrade: websocket",
-      "Connection: Upgrade",
-      `Sec-WebSocket-Accept: ${accept}`,
-      "",
-      "",
-    ].join("\r\n"),
-  );
-
-  const messageHandlers: Array<(data: unknown) => void> = [];
-  const closeHandlers: Array<() => void> = [];
-  let buffer = Buffer.alloc(0);
-
-  socket.on("data", (chunk: Buffer) => {
-    buffer = Buffer.concat([buffer, chunk]);
-    while (true) {
-      const frame = readFrame(buffer);
-      if (!frame) break;
-      buffer = buffer.subarray(frame.bytesRead);
-      if (frame.opcode === 8) {
-        socket.end();
-        break;
-      }
-      if (frame.opcode !== 1) continue;
-      try {
-        const parsed = JSON.parse(frame.payload.toString("utf8"));
-        for (const handler of messageHandlers) {
-          handler(parsed);
-        }
-      } catch {
-        // Ignore malformed client frames; the GUI reconnects on protocol errors.
-      }
-    }
-  });
-
-  socket.on("close", () => {
-    for (const handler of closeHandlers) {
-      handler();
-    }
-  });
-  socket.on("error", () => {
-    for (const handler of closeHandlers) {
-      handler();
-    }
-  });
-
-  return {
-    send(data) {
-      if (socket.destroyed) return;
-      socket.write(writeFrame(Buffer.from(JSON.stringify(data), "utf8")));
-    },
-    close() {
-      socket.end();
-    },
-    onMessage(handler) {
-      messageHandlers.push(handler);
-    },
-    onClose(handler) {
-      closeHandlers.push(handler);
-    },
-  };
-}
-
-function readFrame(buffer: Buffer): { opcode: number; payload: Buffer; bytesRead: number } | null {
-  if (buffer.length < 2) return null;
-
-  const opcode = buffer[0] & 0x0f;
-  let length = buffer[1] & 0x7f;
-  let offset = 2;
-
-  if (length === 126) {
-    if (buffer.length < offset + 2) return null;
-    length = buffer.readUInt16BE(offset);
-    offset += 2;
-  } else if (length === 127) {
-    if (buffer.length < offset + 8) return null;
-    const big = buffer.readBigUInt64BE(offset);
-    if (big > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("Frame too large");
-    length = Number(big);
-    offset += 8;
-  }
-
-  const masked = (buffer[1] & 0x80) !== 0;
-  const mask = masked ? buffer.subarray(offset, offset + 4) : null;
-  if (masked) offset += 4;
-  if (buffer.length < offset + length) return null;
-
-  const payload = Buffer.from(buffer.subarray(offset, offset + length));
-  if (mask) {
-    for (let i = 0; i < payload.length; i++) {
-      payload[i] ^= mask[i % 4];
-    }
-  }
-
-  return { opcode, payload, bytesRead: offset + length };
-}
-
-function writeFrame(payload: Buffer): Buffer {
-  if (payload.length < 126) {
-    return Buffer.concat([Buffer.from([0x81, payload.length]), payload]);
-  }
-  if (payload.length <= 65535) {
-    const header = Buffer.alloc(4);
-    header[0] = 0x81;
-    header[1] = 126;
-    header.writeUInt16BE(payload.length, 2);
-    return Buffer.concat([header, payload]);
-  }
-  const header = Buffer.alloc(10);
-  header[0] = 0x81;
-  header[1] = 127;
-  header.writeBigUInt64BE(BigInt(payload.length), 2);
-  return Buffer.concat([header, payload]);
-}

package/gui/server/writer-lock.ts

@@ -1 +0,0 @@
-export * from "../../src/pi/session-writer-lock.js";