@adhdev/daemon-core 0.8.33 → 0.8.35

package/src/logging/logger.d.ts

@@ -0,0 +1,89 @@
+/**
+ * ADHDev Daemon — unified logger (v2)
+ *
+ * log level: DEBUG < INFO < WARN < ERROR
+ *
+ * Features:
+ * 1. daemonLog(category, msg, level) — explicit per-category logging
+ * 2. installGlobalInterceptor() — Auto-intercept console.log (once on daemon start)
+ * 3. Recent log ring buffer — for remote transmission via P2P/WS
+ * 4. File logging — ~/Library/Logs/adhdev/daemon.log (10MB rolling)
+ *
+ * use:
+ * import { daemonLog, LOG } from './daemon-logger';
+ * LOG.info('CDP', 'Connected to cursor on port 9333');
+ * LOG.debug('StatusReport', 'P2P heartbeat sent');
+ * LOG.warn('IdeInstance', 'onTick error: ...');
+ * LOG.error('Server', 'WebSocket disconnected');
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export declare function setLogLevel(level: LogLevel): void;
+export declare function getLogLevel(): LogLevel;
+export declare function getDaemonLogDir(): string;
+export declare function getCurrentDaemonLogPath(date?: Date): string;
+export interface LogEntry {
+    ts: number;
+    level: LogLevel;
+    category: string;
+    message: string;
+}
+/** Get recent N logs (for remote transmission) */
+export declare function getRecentLogs(count?: number, minLevel?: LogLevel): LogEntry[];
+/** Ring buffer current size */
+export declare function getLogBufferSize(): number;
+/**
+ * Explicit per-category logging
+ * level filter apply, File logging, Ring buffer save
+ */
+export declare function daemonLog(category: string, msg: string, level?: LogLevel): void;
+/**
+ * Scoped logger instance for a specific component.
+ * Created via LOG.forComponent('CDP:cursor').
+ */
+export interface ScopedLogger {
+    debug: (msg: string) => void;
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    /** Returns a plain (msg: string) => void function at the given level.
+     *  Useful as logFn callback for ProviderLoader, DaemonStatusReporter, etc. */
+    asLogFn: (level?: LogLevel) => (msg: string) => void;
+}
+/**
+ * LOG — unified logging API
+ *
+ * Usage:
+ *   LOG.info('CDP', 'Connected to cursor on port 9333');
+ *   LOG.debug('StatusReport', 'P2P heartbeat sent');
+ *
+ * Component-scoped logger:
+ *   const log = LOG.forComponent('ACP:cursor');
+ *   log.info('Session created');
+ *   log.debug('Heartbeat');
+ *
+ * As callback for external components:
+ *   new ProviderLoader({ logFn: LOG.forComponent('Provider').asLogFn() });
+ *   new DaemonStatusReporter({ logFn: LOG.forComponent('Status').asLogFn() });
+ */
+export declare const LOG: {
+    debug: (category: string, msg: string) => void;
+    info: (category: string, msg: string) => void;
+    warn: (category: string, msg: string) => void;
+    error: (category: string, msg: string) => void;
+    /**
+     * Create a scoped logger for a specific component.
+     * Category is baked in so callers only pass the message.
+     */
+    forComponent(category: string): ScopedLogger;
+};
+/**
+ * console.log/warn/error global interceptor install
+ * Prevent recording in places not using daemonLog.
+ * daemon start when 1time call.
+ */
+export declare function installGlobalInterceptor(): void;
+/** current log file path (dateper) */
+export declare function getLogPath(): string;
+/** LOG_PATH — backward compat (current date file) */
+export declare const LOG_PATH: string;
+export declare const LOG_DIR_PATH: string;

package/src/providers/acp-provider-instance.d.ts

@@ -0,0 +1,102 @@
+/**
+ * AcpProviderInstance — ACP (Agent Client Protocol) Provider runtime instance
+ *
+ * Spawns ACP agent process and communicates via the official ACP SDK.
+ * Uses ClientSideConnection + ndJsonStream for structured protocol communication.
+ *
+ * ACP spec: https://agentclientprotocol.com
+ * ACP SDK: @agentclientprotocol/sdk@0.16.1
+ *
+ * lifecycle:
+ * 1. init() → Spawn agent process + ACP initialize handshake
+ * 2. onTick() → no-op (ACP event based)
+ * 3. getState() → ProviderState return (dashboard for display)
+ * 4. onEvent('send_message') → session/prompt transmit
+ * 5. dispose() → kill process
+ */
+import type { ProviderModule, ContentBlock } from './contracts.js';
+import type { ProviderInstance, AcpProviderState, InstanceContext } from './provider-instance.js';
+export declare class AcpProviderInstance implements ProviderInstance {
+    private cliArgs;
+    readonly type: string;
+    readonly category: "acp";
+    private readonly log;
+    private provider;
+    private context;
+    private settings;
+    private events;
+    private monitor;
+    private process;
+    private connection;
+    private sessionId;
+    private messages;
+    private currentStatus;
+    private lastStatus;
+    private generatingStartedAt;
+    private agentCapabilities;
+    private currentModel;
+    private currentMode;
+    private activeToolCalls;
+    private stopReason;
+    private partialContent;
+    /** Rich content blocks accumulated during streaming */
+    private partialBlocks;
+    /** Tool calls collected during current turn */
+    private turnToolCalls;
+    private errorMessage;
+    private errorReason;
+    private stderrBuffer;
+    private spawnedAt;
+    private configOptions;
+    private availableModes;
+    /** Static config mode — agent doesn't support config/* methods */
+    private useStaticConfig;
+    /** Current config selections (for spawnArgBuilder) */
+    private selectedConfig;
+    private workingDir;
+    private instanceId;
+    constructor(provider: ProviderModule, workingDir: string, cliArgs?: string[]);
+    init(context: InstanceContext): Promise<void>;
+    onTick(): Promise<void>;
+    getState(): AcpProviderState;
+    onEvent(event: string, data?: any): void;
+    getInstanceId(): string;
+    private parseConfigOptions;
+    private parseModes;
+    setConfigOption(category: string, value: string): Promise<void>;
+    setMode(modeId: string): Promise<void>;
+    /** Static config: kill process and restart with new args */
+    private restartWithNewConfig;
+    /** Update settings at runtime (called when user changes settings from dashboard) */
+    updateSettings(newSettings: Record<string, any>): void;
+    dispose(): void;
+    private spawnAgent;
+    private createClient;
+    private initialize;
+    private createSession;
+    sendPrompt(text: string, contentBlocks?: ContentBlock[]): Promise<void>;
+    private cancelSession;
+    private permissionResolvers;
+    resolvePermission(approved: boolean): Promise<void>;
+    private handleSessionUpdate;
+    /** Handle legacy session/update formats (pre-standardization compat) */
+    private handleLegacyUpdate;
+    /** Map SDK ToolCallStatus to internal status */
+    private mapToolCallStatus;
+    /** Truncate content for transport (text: 2000 chars, images preserved) */
+    private truncateContent;
+    /** Build ContentBlock[] from current partial state */
+    private buildPartialBlocks;
+    /** Finalize streaming content into an assistant message */
+    private finalizeAssistantMessage;
+    /** Convert ACP ToolCallContent[] to our ToolCallContent[] */
+    private convertToolCallContent;
+    private detectStatusTransition;
+    private pushEvent;
+    private appendSystemMessage;
+    private flushEvents;
+    get cliType(): string;
+    get cliName(): string;
+    /** ACP Agent capabilities (available after initialize) */
+    getCapabilities(): Record<string, any>;
+}

package/src/providers/approval-utils.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderModule } from './contracts.js';
+export declare function getApprovalPositiveHints(provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): string[];
+export declare function pickApprovalButton(buttons: string[] | null | undefined, provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): {
+    index: number;
+    label: string;
+};
+export declare function formatAutoApprovalMessage(modalMessage?: string, buttonLabel?: string): string;

package/src/providers/cli-provider-instance.d.ts

@@ -0,0 +1,86 @@
+/**
+ * CliProviderInstance — Runtime instance for CLI Provider
+ *
+ * Lifecycle layer on top of ProviderCliAdapter.
+ * collectCliData() + status transition logic from daemon-status.ts moved here.
+ */
+import type { ProviderModule } from './contracts.js';
+import type { ProviderInstance, ProviderState, InstanceContext } from './provider-instance.js';
+import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
+import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
+export declare class CliProviderInstance implements ProviderInstance {
+    private provider;
+    private workingDir;
+    private cliArgs;
+    readonly type: string;
+    readonly category: "cli";
+    private adapter;
+    private context;
+    private events;
+    private lastStatus;
+    private generatingStartedAt;
+    private settings;
+    private monitor;
+    private generatingDebounceTimer;
+    private generatingDebouncePending;
+    private lastApprovalEventAt;
+    private controlValues;
+    private appliedEffectKeys;
+    private historyWriter;
+    private runtimeMessages;
+    readonly instanceId: string;
+    private suppressIdleHistoryReplay;
+    private presentationMode;
+    private providerSessionId?;
+    private launchMode;
+    private readonly startedAt;
+    private onProviderSessionResolved?;
+    constructor(provider: ProviderModule, workingDir: string, cliArgs?: string[], instanceId?: string, transportFactory?: PtyTransportFactory, options?: {
+        providerSessionId?: string;
+        launchMode?: 'new' | 'resume' | 'manual';
+        onProviderSessionResolved?: (info: {
+            instanceId: string;
+            providerType: string;
+            providerName: string;
+            workspace: string;
+            providerSessionId: string;
+            previousProviderSessionId?: string;
+        }) => void;
+    });
+    init(context: InstanceContext): Promise<void>;
+    onTick(): Promise<void>;
+    /**
+     * Generic session ID probe using declarative ProviderSessionProbe config.
+     * Replaces the previously duplicated probeOpenCode/Codex/Goose functions.
+     */
+    private probeSessionIdFromConfig;
+    getState(): ProviderState;
+    setPresentationMode(mode: 'terminal' | 'chat'): void;
+    getPresentationMode(): 'terminal' | 'chat';
+    updateSettings(newSettings: Record<string, any>): void;
+    onEvent(event: string, data?: any): void;
+    dispose(): void;
+    private completedDebounceTimer;
+    private completedDebouncePending;
+    private detectStatusTransition;
+    private pushEvent;
+    private flushEvents;
+    private applyProviderResponse;
+    private getEffectDedupKey;
+    private getPersistedEffectContent;
+    getAdapter(): ProviderCliAdapter;
+    get cliType(): string;
+    get cliName(): string;
+    private shouldAutoApprove;
+    private recordAutoApproval;
+    recordApprovalSelection(buttonText: string): void;
+    private formatMarkerTimestamp;
+    private maybeAppendRuntimeRecoveryMessage;
+    private appendRuntimeSystemMessage;
+    private mergeConversationMessages;
+    private formatApprovalRequestMessage;
+    private promoteProviderSessionId;
+    private getProbeDirectories;
+    private buildSqlPlaceholderList;
+    private querySqliteText;
+}

package/src/providers/contracts.d.ts

@@ -23,6 +23,10 @@ export interface ReadChatResult {
     inputContent?: string;
     model?: string;
     autoApprove?: string;
+    /** Explicit dynamic control values returned by the provider */
+    controlValues?: Record<string, string | number | boolean>;
+    /** Provider-driven UI effects derived from chat state */
+    effects?: ProviderEffect[];
 }
 import type { ChatMessage } from '../types.js';
 export type { ChatMessage };
@@ -33,6 +37,38 @@ export interface ModalInfo {
     width?: number;
     height?: number;
 }
+export interface ProviderEffectMessage {
+    role?: 'system' | 'assistant' | 'user';
+    content: string | ContentBlock[];
+    kind?: string;
+    senderName?: string;
+}
+export interface ProviderEffectToast {
+    level?: 'info' | 'success' | 'warning';
+    message: string;
+}
+export type ProviderNotificationPreferenceKey = 'disconnect' | 'completion' | 'approval' | 'browser';
+export type ProviderNotificationChannel = 'bubble' | 'toast' | 'browser';
+export interface ProviderEffectNotification {
+    title?: string;
+    body: string;
+    level?: 'info' | 'success' | 'warning';
+    channels?: ProviderNotificationChannel[];
+    preferenceKey?: ProviderNotificationPreferenceKey;
+    bubbleContent?: string | ContentBlock[];
+}
+export interface ProviderEffect {
+    type: 'message' | 'toast' | 'notification';
+    /** Stable dedup key; falls back to a content hash when omitted */
+    id?: string;
+    /** Default immediate. turn_completed fires only on generating/waiting -> idle transitions. */
+    when?: 'immediate' | 'turn_completed';
+    /** Default true. False keeps the effect UI-only. */
+    persist?: boolean;
+    message?: ProviderEffectMessage;
+    toast?: ProviderEffectToast;
+    notification?: ProviderEffectNotification;
+}
 /**
  * ContentBlock — ACP ContentBlock union type
  * Represents displayable content in messages, tool call results, etc.
@@ -197,6 +233,11 @@ export interface CdpTargetFilter {
     /** Page title regex pattern for titles to EXCLUDE (e.g. 'Debug Console|Output') */
     titleExcludes?: string;
 }
+export type ProviderVersionCommand = string | Partial<Record<string, string>>;
+export interface ProviderCompatibilityEntry {
+    ideVersion: string;
+    scriptDir: string;
+}
 export interface ProviderModule {
     /** Unique identifier (e.g. 'cline', 'cursor', 'gemini-cli') */
     type: string;
@@ -219,7 +260,7 @@ export interface ProviderModule {
     /** Install instructions (shown when command is missing) */
     install?: string;
     /** Custom version detection command (e.g. 'cursor --version', 'claude -v') */
-    versionCommand?: string;
+    versionCommand?: ProviderVersionCommand;
     /** Versions tested by provider maintainer (informational) */
     testedVersions?: string[];
     /** Per-OS process names — used by launch.ts to detect/kill IDE processes */
@@ -229,6 +270,28 @@ export interface ProviderModule {
         linux?: string[];
         [key: string]: string | string[] | undefined;
     };
+    /**
+     * IDE launch preferences.
+     * Lets each provider choose how its GUI app should be started per platform.
+     */
+    launch?: {
+        /**
+         * Preferred launch method by platform.
+         * - 'cli': use the IDE CLI wrapper/binary
+         * - 'app': use platform app launcher (e.g. `open -a` on macOS)
+         * - 'auto': let core choose a sensible default
+         */
+        prefer?: {
+            darwin?: 'auto' | 'cli' | 'app';
+            win32?: 'auto' | 'cli' | 'app';
+            linux?: 'auto' | 'cli' | 'app';
+            [key: string]: 'auto' | 'cli' | 'app' | undefined;
+        };
+        /**
+         * Override how long core waits for CDP to come up after launch.
+         */
+        cdpStartupTimeoutMs?: number;
+    };
     /** Per-OS install paths — used by detector.ts to detect IDE installation */
     paths?: {
         darwin?: string[];
@@ -238,6 +301,9 @@ export interface ProviderModule {
     };
     extensionId?: string;
     extensionIdPattern?: RegExp;
+    extensionIdPattern_flags?: string;
+    compatibility?: ProviderCompatibilityEntry[];
+    defaultScriptDir?: string;
     binary?: string;
     spawn?: {
         command: string;
@@ -245,6 +311,7 @@ export interface ProviderModule {
         shell?: boolean;
         env?: Record<string, string>;
     };
+    approvalKeys?: Record<number, string>;
     patterns?: {
         prompt?: RegExp[];
         generating?: RegExp[];
@@ -253,6 +320,9 @@ export interface ProviderModule {
     };
     cleanOutput?: (raw: string, lastUserInput?: string) => string;
     resume?: ProviderResumeCapability;
+    /** Session ID probe config — auto-discovers provider session ID from local SQLite DB */
+    sessionProbe?: ProviderSessionProbe;
+    /** Approval button priority hints used when auto-approve must pick a positive action */
     approvalPositiveHints?: string[];
     scripts?: ProviderScripts;
     vscodeCommands?: {
@@ -288,6 +358,8 @@ export interface ProviderModule {
         __dir?: string;
     }>;
     settings?: Record<string, ProviderSettingDef>;
+    /** Dynamic controls declared by provider — rendered in chat panel bar/header */
+    controls?: ProviderControlDef[];
     /** Static options used when agent does not provide configOptions */
     staticConfigOptions?: Array<{
         category: 'model' | 'mode' | 'thought_level' | 'other';
@@ -310,7 +382,46 @@ export interface ProviderResumeCapability {
     stopStrategy?: 'command' | 'ctrl_c';
     stopCommand?: string;
     shutdownGraceMs?: number;
+    /** Delay (ms) between Ctrl+C interrupt and stop command (default 500ms) */
+    interruptGraceMs?: number;
     resumeArgs?: string[];
+    resumeSessionArgs?: string[];
+    newSessionArgs?: string[];
+    sessionIdFormat?: 'uuid' | 'string';
+}
+/**
+ * Declarative session ID probe config for CLI providers.
+ * Instead of hardcoded probe functions, providers declare their SQLite schema.
+ *
+ * Example (OpenCode):
+ * ```
+ * sessionProbe: {
+ *   dbPath: '~/.local/share/opencode/opencode.db',
+ *   query: 'SELECT id FROM session WHERE directory IN ({dirs}) AND time_created >= ? AND time_archived IS NULL ORDER BY time_updated DESC LIMIT 1',
+ *   timestampFormat: 'unix_ms',
+ * }
+ * ```
+ */
+export interface ProviderSessionProbe {
+    /**
+     * Path to SQLite database. Supports ~ for home directory.
+     * Supports platform-specific paths via {platform} placeholder.
+     */
+    dbPath: string;
+    /**
+     * SQL query to find the session ID.
+     * Use {dirs} placeholder for the directory IN-clause parameters.
+     * The query must SELECT a column named 'id'.
+     * A '?' placeholder after {dirs} receives the min-created-at timestamp.
+     */
+    query: string;
+    /**
+     * How the provider stores timestamps.
+     * - 'unix_ms': milliseconds since epoch (default)
+     * - 'unix_s': seconds since epoch
+     * - 'iso': ISO 8601 string (YYYY-MM-DD HH:MM:SS)
+     */
+    timestampFormat?: 'unix_ms' | 'unix_s' | 'iso';
 }
 /** ACP auth method — based on ACP official spec */
 export type AcpAuthMethod = AcpAuthEnvVar | AcpAuthAgent | AcpAuthTerminal;
@@ -385,6 +496,14 @@ export interface ResolvedProvider extends ProviderModule {
     _resolvedVersion?: string;
     /** Warning when detected version is not in compatibility matrix */
     _versionWarning?: string;
+    /** On-disk provider directory selected by ProviderLoader */
+    _resolvedProviderDir?: string;
+    /** Script directory selected by compatibility/default resolution */
+    _resolvedScriptDir?: string;
+    /** scripts.js path or fallback script directory used to build runtime scripts */
+    _resolvedScriptsPath?: string;
+    /** Why this script selection was chosen */
+    _resolvedScriptsSource?: string;
 }
 /** Setting variable definition declared by provider */
 export interface ProviderSettingDef {
@@ -407,3 +526,76 @@ export interface ProviderSettingDef {
 export interface ProviderSettingSchema extends ProviderSettingDef {
     key: string;
 }
+/**
+ * Control types:
+ * - 'select'  — dropdown list (model picker, mode picker)
+ * - 'toggle'  — on/off switch (compact mode, auto-approve)
+ * - 'cycle'   — click-to-cycle through options (thinking level: low→med→high)
+ * - 'slider'  — numeric range (temperature: 0–2)
+ * - 'action'  — one-shot button (show usage, restart, clear context)
+ */
+export type ProviderControlType = 'select' | 'toggle' | 'cycle' | 'slider' | 'action' | 'display';
+/**
+ * Where the control appears in the chat UI:
+ * - 'bar'    — thin strip below/above the chat input (always visible)
+ * - 'header' — in the agent header area
+ * - 'menu'   — inside a ⋯ overflow menu
+ */
+export type ProviderControlPlacement = 'bar' | 'header' | 'menu';
+/** Static option for select/cycle controls */
+export interface ProviderControlOption {
+    value: string;
+    label: string;
+    description?: string;
+    group?: string;
+}
+/**
+ * ProviderControlDef — A single interactive control declared by a provider.
+ *
+ * Controls are different from Settings:
+ * - Settings: background config, infrequently changed, managed in settings page
+ * - Controls: interactive, changed during chat, rendered inside chat panel
+ *
+ * Each control maps to provider scripts for get/set operations.
+ * The frontend renders controls automatically based on this schema —
+ * no hardcoded model/mode assumptions needed.
+ *
+ * For 'action' type:
+ * - Renders as a button. On click → calls invokeScript.
+ * - No value state. Optionally shows result via toast/inline.
+ */
+export interface ProviderControlDef {
+    /** Unique identifier (e.g. 'model', 'mode', 'thinking', 'usage') */
+    id: string;
+    /** Control type */
+    type: ProviderControlType;
+    /** Display label */
+    label: string;
+    /** Icon (emoji or icon name) */
+    icon?: string;
+    /** Where to show this control in the UI */
+    placement: ProviderControlPlacement;
+    /** Static options — used when the list is known at definition time */
+    options?: ProviderControlOption[];
+    /** Dynamic options — load via script at runtime */
+    dynamic?: boolean;
+    /** Script name to list options (e.g. 'listModels') — required when dynamic=true */
+    listScript?: string;
+    /** Script name to change value (e.g. 'setModel') — required for value-based controls */
+    setScript?: string;
+    /** Field name in readChat() result to read current value (e.g. 'model', 'mode') */
+    readFrom?: string;
+    /** Default value */
+    defaultValue?: string | number | boolean;
+    /** Script name to invoke (one-shot call, no value) */
+    invokeScript?: string;
+    /** How to display action result: 'toast' = notification, 'inline' = show in bar, 'none' = silent */
+    resultDisplay?: 'toast' | 'inline' | 'none';
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Sort order within placement group (lower = first) */
+    order?: number;
+    /** Hide this control when condition not met */
+    hidden?: boolean;
+}

package/src/providers/control-effects.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderControlDef, ProviderEffect } from './contracts.js';
+export type ProviderControlValue = string | number | boolean;
+export declare function extractProviderControlValues(controls: ProviderControlDef[] | undefined, data: any): Record<string, ProviderControlValue> | undefined;
+export declare function normalizeProviderEffects(data: any): ProviderEffect[];

package/src/providers/extension-provider-instance.d.ts

@@ -0,0 +1,61 @@
+/**
+ * ExtensionProviderInstance — Runtime instance for Extension Provider
+ *
+ * Manages IDE extensions (Cline, Roo Code, etc).
+ * CDP webview discovery + agent stream collection moved here.
+ */
+import type { ProviderModule } from './contracts.js';
+import type { ProviderInstance, ProviderState, InstanceContext } from './provider-instance.js';
+export declare class ExtensionProviderInstance implements ProviderInstance {
+    readonly type: string;
+    readonly category: "extension";
+    private provider;
+    private context;
+    private settings;
+    private events;
+    private currentStatus;
+    private agentStreams;
+    private messages;
+    private prevMessageHashes;
+    private activeModal;
+    private currentModel;
+    private currentMode;
+    private controlValues;
+    private appliedEffectKeys;
+    private runtimeMessages;
+    private lastAgentStatus;
+    private generatingStartedAt;
+    private monitor;
+    private historyWriter;
+    private instanceId;
+    private ideType;
+    private chatId;
+    private chatTitle;
+    private agentName;
+    private extensionId;
+    constructor(provider: ProviderModule);
+    init(context: InstanceContext): Promise<void>;
+    onTick(): Promise<void>;
+    getState(): ProviderState;
+    onEvent(event: string, data?: any): void;
+    dispose(): void;
+    updateSettings(newSettings: Record<string, any>): void;
+    /** Query UUID instanceId */
+    getInstanceId(): string;
+    private detectTransition;
+    private pushEvent;
+    private applyProviderResponse;
+    private appendRuntimeSystemMessage;
+    /**
+     * Assign stable receivedAt to extension messages.
+     * Same pattern as IdeProviderInstance.readChat() prevByHash —
+     * preserves first-seen timestamp across polling cycles.
+     */
+    private assignReceivedAt;
+    private mergeConversationMessages;
+    private getPersistedEffectContent;
+    private getEffectDedupKey;
+    private flushEvents;
+    private resolveChatTitle;
+    private resetStreamState;
+}