twinny 0.0.0-dev.260525150705

package/dist/conversation/manager.d.ts

@@ -0,0 +1,701 @@
+import type { Logger } from "pino";
+import { type LarkCardJson } from "../lark/cards.js";
+import type { CodexThreadTokenUsageUpdate, CodexTurnResult, CodexAgentMessage, CodexImageGeneration, CodexPlanUpdate, CodexRequestUserInputRequest, CodexThreadGoalStatus, CodexThreadMode, CodexThreadNameUpdate, CodexThreadStatus, ConversationResponseMode, ConversationRecord, ConversationType, IncomingLarkBotMenuAction, IncomingLarkCardAction, IncomingLarkMessage, IncomingLarkMessageRecall, LarkMessageRecord, LarkMessageRouteKind, LarkMessageStatus, LarkReactionHandle, NewConversationRecord, ProfileName, CodexThreadRecord, TwinnyConfig, LarkChatMode, LarkGroupMessageType } from "../types.js";
+import { type CodexDynamicToolCallResponse, type CodexRequestUserInputResponder, type CodexSetThreadNameToolRequest, type CodexTurnInput } from "../codex/turn.js";
+import type { ThreadGoal } from "../codex/goal.js";
+import type { LarkSendMessageResult } from "../lark/types.js";
+import type { TelemetryClient } from "../telemetry/index.js";
+export interface ConversationRepository {
+    findByConversationKey(conversationKey: string): Promise<ConversationRecord | null> | ConversationRecord | null;
+    create(record: NewConversationRecord): Promise<ConversationRecord> | ConversationRecord;
+    updateThreadBinding(conversationKey: string, update: {
+        codexThreadId: string;
+        profile?: ProfileName;
+        profileCodexHome?: string;
+        workspace?: string;
+    }): Promise<ConversationRecord> | ConversationRecord;
+    updateConversationSettings(conversationKey: string, update: {
+        type?: ConversationType;
+        name?: string;
+        responseMode?: ConversationResponseMode;
+    }): Promise<ConversationRecord> | ConversationRecord;
+    markThreadHasRollout(conversationKey: string, codexThreadId: string): Promise<void> | void;
+    getCodexThreadById(codexThreadId: string): Promise<CodexThreadRecord | undefined> | CodexThreadRecord | undefined;
+    getCodexThreadByConversationAndLarkThread(conversationKey: string, larkThreadId: string): Promise<CodexThreadRecord | undefined> | CodexThreadRecord | undefined;
+    getLarkMessageById(larkMessageId: string): Promise<unknown | undefined> | unknown | undefined;
+    getLarkMessageByEventId(eventId: string): Promise<unknown | undefined> | unknown | undefined;
+    getLarkMessageUsageTargetForTurn(codexThreadId: string, codexTurnId: string): Promise<LarkMessageRecord | undefined> | LarkMessageRecord | undefined;
+    getLatestSteeredLarkMessageForTurn(codexThreadId: string, codexTurnId: string): Promise<LarkMessageRecord | undefined> | LarkMessageRecord | undefined;
+    listUnfinishedLarkMessages(): Promise<LarkMessageRecord[]> | LarkMessageRecord[];
+    upsertCodexThread(input: {
+        codexThreadId: string;
+        conversationKey: string;
+        profile: ProfileName;
+        model?: string;
+        effort?: string;
+        larkThreadId?: string;
+        codexThreadHasRollout?: boolean;
+        forkedFromCodexThreadId?: string;
+        forkedAt?: number;
+        name?: string;
+    }): Promise<unknown> | unknown;
+    replaceCodexThreadForLarkThread?(conversationKey: string, larkThreadId: string, update: {
+        codexThreadId: string;
+        profile: ProfileName;
+        model?: string;
+        effort?: string;
+        codexThreadHasRollout?: boolean;
+    }): Promise<CodexThreadRecord> | CodexThreadRecord;
+    updateCodexThreadTokenUsage(input: {
+        codexThreadId: string;
+        conversationKey: string;
+        profile: ProfileName;
+        totalTokens: number;
+        inputTokens: number;
+        outputTokens: number;
+        cachedInputTokens: number;
+        reasoningOutputTokens: number;
+        contextTokens: number;
+        contextWindow: number;
+        tokenUsageJson: string;
+    }): Promise<unknown> | unknown;
+    updateCodexThreadCard(input: {
+        codexThreadId: string;
+        conversationKey: string;
+        profile: ProfileName;
+        model?: string;
+        effort?: string;
+        larkThreadId?: string;
+        creatorOpenId?: string;
+        cardMessageId?: string;
+        name?: string;
+    }): Promise<CodexThreadRecord> | CodexThreadRecord;
+    updateCodexThreadModelSettings(input: {
+        codexThreadId: string;
+        model: string;
+        effort: string;
+    }): Promise<CodexThreadRecord> | CodexThreadRecord;
+    updateCodexThreadName(codexThreadId: string, name: string): Promise<CodexThreadRecord | undefined> | CodexThreadRecord | undefined;
+    updateCodexThreadMode(conversationKey: string, codexThreadId: string, mode: CodexThreadMode): Promise<CodexThreadRecord> | CodexThreadRecord;
+    updateCodexThreadStatus(conversationKey: string, codexThreadId: string, status: CodexThreadStatus): Promise<CodexThreadRecord> | CodexThreadRecord;
+    updateCodexThreadGoalStatus(input: {
+        codexThreadId: string;
+        goalStatus: CodexThreadGoalStatus;
+        goalUpdatedAt?: number;
+    }): Promise<CodexThreadRecord> | CodexThreadRecord;
+    clearCodexThreadGoalStatus(codexThreadId: string): Promise<CodexThreadRecord> | CodexThreadRecord;
+    getCodexThreadWorkStats(codexThreadId: string): Promise<{
+        turnCount: number;
+        totalWorkDurationMs: number;
+    }> | {
+        turnCount: number;
+        totalWorkDurationMs: number;
+    };
+    getCodexThreadStatusStats(codexThreadId: string): Promise<{
+        userMessageCount: number;
+        turnCount: number;
+        totalWorkDurationMs: number;
+    }> | {
+        userMessageCount: number;
+        turnCount: number;
+        totalWorkDurationMs: number;
+    };
+    getConversationStatusStats(conversationKey: string): Promise<{
+        topicCount: number;
+        userMessageCount: number;
+        inputTokens: number;
+        outputTokens: number;
+        cachedInputTokens: number;
+        reasoningOutputTokens: number;
+        totalTokens: number;
+        totalWorkDurationMs: number;
+    }> | {
+        topicCount: number;
+        userMessageCount: number;
+        inputTokens: number;
+        outputTokens: number;
+        cachedInputTokens: number;
+        reasoningOutputTokens: number;
+        totalTokens: number;
+        totalWorkDurationMs: number;
+    };
+    insertLarkMessage(input: {
+        larkMessageId?: string;
+        eventId: string;
+        larkUserId: string;
+        larkGroupId?: string;
+        larkThreadId?: string;
+        conversationKey?: string;
+        codexThreadId?: string;
+        codexTurnId?: string;
+        routeKind: LarkMessageRouteKind;
+        status: LarkMessageStatus;
+        text: string;
+        larkCreateTime?: number;
+        sideId?: number;
+        agentCardMessageId?: string;
+        rawEventJson?: string;
+    }): Promise<unknown> | unknown;
+    markLarkMessageQueued(larkMessageId: string): Promise<void> | void;
+    markLarkMessageRecalled(larkMessageId: string): Promise<boolean> | boolean;
+    updateQueuedLarkMessage(larkMessageId: string, update: {
+        text: string;
+        rawEventJson?: string;
+    }): Promise<boolean> | boolean;
+    updateLarkMessageSideMetadata?(larkMessageId: string, update: {
+        sideId?: number;
+        agentCardMessageId?: string;
+    }): Promise<boolean> | boolean;
+    updateLarkMessageTokenUsage(input: {
+        larkMessageId: string;
+        inputTokens: number;
+        outputTokens: number;
+        cachedInputTokens: number;
+        reasoningOutputTokens: number;
+        tokenUsageJson: string;
+    }): Promise<LarkMessageRecord | undefined> | LarkMessageRecord | undefined;
+    markLarkMessagesProcessing(larkMessageIds: string[], update?: {
+        conversationKey?: string;
+        codexThreadId?: string;
+        codexTurnId?: string;
+    }): Promise<void> | void;
+    markLarkMessagesSteered(larkMessageIds: string[], update?: {
+        conversationKey?: string;
+        codexThreadId?: string;
+        codexTurnId?: string;
+    }): Promise<void> | void;
+    markLarkMessagesCompleted(larkMessageIds: string[]): Promise<void> | void;
+    markLarkMessagesFailed(larkMessageIds: string[]): Promise<void> | void;
+    markLarkMessagesInterrupted(larkMessageIds: string[]): Promise<void> | void;
+    markLarkMessagesCleared(larkMessageIds: string[]): Promise<void> | void;
+}
+export interface LarkUserDirectory {
+    getUserNameByOpenId(openId: string): Promise<string | undefined>;
+}
+export interface LarkChatDirectory {
+    getChatInfo?(chatId: string): Promise<{
+        name?: string;
+        chatMode?: LarkChatMode | "p2p";
+        groupMessageType?: LarkGroupMessageType;
+    } | undefined>;
+    getChatName?(chatId: string): Promise<string | undefined>;
+}
+export interface LarkFileDownloader {
+    downloadMessageResource(params: {
+        messageId: string;
+        resourceType: "image" | "file";
+        fileKey: string;
+        fileName?: string;
+        outputDir: string;
+    }): Promise<{
+        path: string;
+        resourceType: "image" | "file";
+        fileKey: string;
+        fileName?: string;
+        size: number;
+        contentType?: string;
+    }>;
+    uploadImage?(params: {
+        filePath: string;
+        fileName?: string;
+        contentType?: string;
+    }): Promise<{
+        imageKey: string;
+        raw?: unknown;
+    }>;
+    uploadFile?(params: {
+        filePath: string;
+        fileName?: string;
+        fileType?: string;
+        contentType?: string;
+        durationMs?: number;
+    }): Promise<{
+        fileKey: string;
+        raw?: unknown;
+    }>;
+}
+export interface LarkMessageReader {
+    getMessage(messageId: string): Promise<unknown>;
+    getMessageItems?(messageId: string): Promise<unknown[]>;
+}
+export interface WorkspaceManagerLike {
+    ensureWorkspace(conversationKey: string): Promise<string> | string;
+}
+export interface CodexBridge {
+    startThread(params: {
+        profile: ProfileName;
+        cwd: string;
+        approvalPolicy: "never";
+        developerInstructions?: string;
+    }): Promise<{
+        threadId: string;
+    }>;
+    resumeThread(params: {
+        profile: ProfileName;
+        threadId: string;
+        cwd: string;
+        approvalPolicy: "never";
+    }): Promise<{
+        threadId: string;
+    }>;
+    forkThread(params: {
+        profile: ProfileName;
+        threadId: string;
+        cwd: string;
+        approvalPolicy: "never";
+        ephemeral?: boolean;
+        developerInstructions?: string;
+        model?: string;
+        effort?: string;
+    }): Promise<{
+        threadId: string;
+    }>;
+    injectThreadItems?(params: {
+        profile: ProfileName;
+        threadId: string;
+        items: unknown[];
+    }): Promise<void>;
+    unsubscribeThread?(params: {
+        profile: ProfileName;
+        threadId: string;
+    }): Promise<void>;
+    startTurn(params: {
+        profile: ProfileName;
+        threadId: string;
+        input: CodexTurnInput;
+        currentThreadName?: string;
+        cwd: string;
+        approvalPolicy: "never";
+        mode?: CodexThreadMode;
+        model?: string;
+        effort?: string;
+        onTurnStarted?: (turnId: string) => Promise<void> | void;
+        onAgentMessage?: (message: CodexAgentMessage) => Promise<void> | void;
+        onImageGeneration?: (image: CodexImageGeneration) => Promise<void> | void;
+        onTokenUsage?: (usage: CodexThreadTokenUsageUpdate) => Promise<void> | void;
+        onGoalUpdated?: (goal: ThreadGoal, turnId: string | null) => Promise<void> | void;
+        onGoalCleared?: () => Promise<void> | void;
+        onPlanUpdated?: (plan: CodexPlanUpdate) => Promise<void> | void;
+        onRequestUserInput?: (request: CodexRequestUserInputRequest, responder: CodexRequestUserInputResponder) => Promise<void> | void;
+        onSetThreadName?: (request: CodexSetThreadNameToolRequest) => Promise<CodexDynamicToolCallResponse> | CodexDynamicToolCallResponse;
+    }): Promise<CodexTurnResult>;
+    compactThread(params: {
+        profile: ProfileName;
+        threadId: string;
+        cwd: string;
+        approvalPolicy: "never";
+        onTurnStarted?: (turnId: string) => Promise<void> | void;
+        onTokenUsage?: (usage: CodexThreadTokenUsageUpdate) => Promise<void> | void;
+    }): Promise<CodexTurnResult>;
+    steerTurn(params: {
+        profile: ProfileName;
+        threadId: string;
+        turnId: string;
+        input: CodexTurnInput;
+        cwd: string;
+        approvalPolicy: "never";
+    }): Promise<void>;
+    interruptTurn(params: {
+        profile: ProfileName;
+        threadId: string;
+        turnId: string;
+    }): Promise<void>;
+    readCodexVersion?(params: {
+        profile: ProfileName;
+    }): Promise<string> | string;
+    readAccountRateLimits?(params: {
+        profile: ProfileName;
+    }): Promise<unknown>;
+    setThreadGoal?(params: {
+        profile: ProfileName;
+        threadId: string;
+        objective: string;
+    }): Promise<ThreadGoal>;
+    getThreadGoal?(params: {
+        profile: ProfileName;
+        threadId: string;
+    }): Promise<ThreadGoal | null>;
+    clearThreadGoal?(params: {
+        profile: ProfileName;
+        threadId: string;
+    }): Promise<void>;
+    setThreadName?(params: {
+        profile: ProfileName;
+        threadId: string;
+        name: string;
+    }): Promise<void>;
+    runGoal?(params: {
+        profile: ProfileName;
+        threadId: string;
+        objective: string;
+        onTurnStarted?: (turnId: string) => Promise<void> | void;
+        onAgentMessage?: (message: CodexAgentMessage) => Promise<void> | void;
+        onTokenUsage?: (usage: CodexThreadTokenUsageUpdate) => Promise<void> | void;
+        onGoalUpdated?: (goal: ThreadGoal, turnId: string | null) => Promise<void> | void;
+        onGoalCleared?: () => Promise<void> | void;
+        onRequestUserInput?: (request: CodexRequestUserInputRequest, responder: CodexRequestUserInputResponder) => Promise<void> | void;
+        onSetThreadName?: (request: CodexSetThreadNameToolRequest) => Promise<CodexDynamicToolCallResponse> | CodexDynamicToolCallResponse;
+    }): Promise<CodexTurnResult>;
+    resumeGoal?(params: {
+        profile: ProfileName;
+        threadId: string;
+        cwd: string;
+        onTurnStarted?: (turnId: string) => Promise<void> | void;
+        onAgentMessage?: (message: CodexAgentMessage) => Promise<void> | void;
+        onTokenUsage?: (usage: CodexThreadTokenUsageUpdate) => Promise<void> | void;
+        onGoalUpdated?: (goal: ThreadGoal, turnId: string | null) => Promise<void> | void;
+        onGoalCleared?: () => Promise<void> | void;
+        onRequestUserInput?: (request: CodexRequestUserInputRequest, responder: CodexRequestUserInputResponder) => Promise<void> | void;
+        onSetThreadName?: (request: CodexSetThreadNameToolRequest) => Promise<CodexDynamicToolCallResponse> | CodexDynamicToolCallResponse;
+    }): Promise<CodexTurnResult>;
+}
+export interface LarkResponder {
+    addTypingReaction(messageId: string): Promise<LarkReactionHandle | null>;
+    addCompletedReaction(messageId: string): Promise<LarkReactionHandle | null>;
+    addQueuedReaction(messageId: string): Promise<LarkReactionHandle | null>;
+    removeReaction(handle: LarkReactionHandle): Promise<void>;
+    replyText(messageId: string, text: string, options?: LarkReplyOptions): Promise<LarkReplyResult | void>;
+    replyMarkdown(messageId: string, markdown: string, options?: LarkReplyOptions): Promise<LarkReplyResult | void>;
+    replyPost(messageId: string, content: LarkPostContent, options?: LarkReplyOptions): Promise<LarkReplyResult | void>;
+    replyFile(messageId: string, fileKey: string): Promise<{
+        messageId?: string;
+    } | void>;
+    replyImage(messageId: string, imageKey: string): Promise<{
+        messageId?: string;
+    } | void>;
+    sendTextToOpenId(openId: string, text: string): Promise<void>;
+    sendCardToOpenId(openId: string, card: LarkCardJson, options?: {
+        uuid?: string;
+    }): Promise<LarkSendMessageResult | void>;
+    sendCardToChatId(chatId: string, card: LarkCardJson, options?: {
+        uuid?: string;
+    }): Promise<LarkSendMessageResult | void>;
+    sendEphemeralCardToChatId(chatId: string, openId: string, card: LarkCardJson): Promise<LarkSendMessageResult | void>;
+    forwardThreadToThread(threadId: string, receiveThreadId: string, options?: {
+        uuid?: string;
+    }): Promise<LarkSendMessageResult | void>;
+    replyCard(messageId: string, card: LarkCardJson, options?: LarkReplyOptions): Promise<LarkReplyResult | void>;
+    patchCard(messageId: string, card: LarkCardJson): Promise<{
+        messageId?: string;
+    } | void>;
+    recallMessage(messageId: string): Promise<void>;
+    deleteEphemeralMessage(messageId: string): Promise<void>;
+    getMessageReadOpenIds(messageId: string): Promise<string[]>;
+}
+export interface ProfileHomeResolver {
+    codexHomeFor(profile: ProfileName): string;
+}
+export interface RuntimeControlBridge {
+    reloadProfile(profile?: ProfileName): Promise<void>;
+}
+export interface ConversationManagerOptions {
+    config: TwinnyConfig;
+    repository: ConversationRepository;
+    workspaces: WorkspaceManagerLike;
+    codex: CodexBridge;
+    lark: LarkResponder;
+    larkUsers?: LarkUserDirectory;
+    larkChats?: LarkChatDirectory;
+    larkFiles?: LarkFileDownloader;
+    larkMessages?: LarkMessageReader;
+    botOpenId?: string;
+    assetImageKeys?: {
+        logoImageKey?: string;
+        bannerImageKey?: string;
+    };
+    profiles: ProfileHomeResolver;
+    runtime?: RuntimeControlBridge;
+    telemetry?: TelemetryClient;
+    logger?: Logger;
+    nameLookupFailureTtlMs?: number;
+}
+export interface ConversationRecoveryProbeFailure {
+    eventId: string;
+    larkMessageId?: string;
+    status: LarkMessageStatus;
+    error: string;
+}
+export interface ConversationRecoveryProbeSnapshot {
+    unfinishedMessages: number;
+    queuedMessages: number;
+    processingMessages: number;
+    recoveredMessages: number;
+    failedMessages: number;
+    stateCount: number;
+    pendingMessages: number;
+    compactMessages: number;
+    profiles: Record<ProfileName, number>;
+    failures: ConversationRecoveryProbeFailure[];
+}
+export interface ConversationRuntimeStats {
+    activeTurnCount: number;
+    sideTurnCount: number;
+    queuedMessageCount: number;
+    suspendedTurnCount: number;
+}
+interface LarkReplyOptions {
+    replyInThread?: boolean;
+}
+interface LarkReplyResult {
+    messageId?: string;
+    raw?: unknown;
+}
+export declare class ConversationManager {
+    private readonly options;
+    private static readonly recoveryPrompt;
+    private readonly states;
+    private readonly nameLookupFailureCache;
+    private readonly pendingThreadNames;
+    private readonly log;
+    private shuttingDown;
+    constructor(options: ConversationManagerOptions);
+    submitIncoming(message: IncomingLarkMessage): void;
+    submitMessageRecall(recall: IncomingLarkMessageRecall): void;
+    submitBotMenuAction(action: IncomingLarkBotMenuAction): void;
+    submitCardAction(action: IncomingLarkCardAction): void;
+    submitCodexThreadNameUpdated(update: CodexThreadNameUpdate): void;
+    shutdown(): Promise<void>;
+    suspendActiveTurnsForCodexAppServerExit(profile: ProfileName): Promise<number>;
+    recoverSuspendedActiveTurnsForCodexAppServerExit(profile: ProfileName): Promise<number>;
+    recoverUnfinishedMessages(options?: {
+        profile?: ProfileName;
+    }): Promise<void>;
+    probeUnfinishedMessages(): Promise<ConversationRecoveryProbeSnapshot>;
+    private profileForRecoverableRecord;
+    private toRecoveredPendingMessage;
+    private startRecoveredProcessingMessages;
+    private getOrCreateRecoveryConversation;
+    queueDepth(conversationKey: string): number;
+    getRuntimeStats(): ConversationRuntimeStats;
+    private processBotMenuAction;
+    private processSubmittedMessage;
+    private handleSubmittedMessageFailure;
+    private isPersistedDuplicateMessage;
+    private enqueueQueuedMessageChange;
+    private processQueuedMessageRecall;
+    private routeMessage;
+    private prepareIncomingMessageForCodex;
+    private expandMergeForwardMessage;
+    private resolveMergeForwardSourceChat;
+    private renderMergeForwardChildMessage;
+    private resolveMergeForwardSenderName;
+    private downloadMergeForwardChildResources;
+    private shouldDropOccupiedControlCommand;
+    private handleRecordedParsedCommand;
+    private recordIncomingMessage;
+    private prepareMessageResources;
+    private applyGroupResponsePolicy;
+    private rejectUnauthorizedP2pBestEffort;
+    private resolveSenderName;
+    private cacheNameLookupFailure;
+    private handleActivateCommand;
+    private handlePairCommand;
+    private handleReloadCommand;
+    private resolveGroupInfo;
+    private handleNewSessionMenuAction;
+    private handleThreadCommand;
+    private handleForkCommand;
+    private resolveForkSourceThread;
+    private replyThreadCommandMessage;
+    private prepareThreadReplyPostResources;
+    private replyThreadTextMessage;
+    private updateSessionTopicThreadId;
+    private forwardSessionTopicToSourceThreadBestEffort;
+    private createNewSessionTopic;
+    private handleDeactivateCommand;
+    private cancelConversationStates;
+    private handleUserMessage;
+    private handleQueueCommand;
+    private handleGoalCommand;
+    private updateActiveGoalCommand;
+    private handleSideCommand;
+    private beginSideTurn;
+    private handlePlanCommand;
+    private handleExitCommand;
+    private handleCompactCommand;
+    private handleLogoCommand;
+    private handleBannerCommand;
+    private handleHelpCommand;
+    private handleStatusCommand;
+    private handleModelCommand;
+    private resolveCurrentThreadForModelCommand;
+    private formatStatusCard;
+    private formatStatusText;
+    private formatOwnerRateLimitStatus;
+    private formatOwnerRateLimitCardStatus;
+    private handleStopCommand;
+    private stopConversationState;
+    private processStatusCardHideAction;
+    private processCardAction;
+    private findActiveTurnForCardAction;
+    private executeStopAction;
+    private executeNextAction;
+    private executeQueueAction;
+    private executeRequestInputSubmitAction;
+    private executeRequestInputSkipAction;
+    private executePlanImplementAction;
+    private recordMenuActionBestEffort;
+    private recordCardActionBestEffort;
+    private captureMessageReceived;
+    private captureMenuActionReceived;
+    private captureCardActionReceived;
+    private handleNextCommand;
+    private handleSteerCommand;
+    private handleNewCommand;
+    private openNewThreadForMessage;
+    private steerOrDefer;
+    private startPendingBatch;
+    private schedulePendingMessage;
+    private tryRunPendingMessageDirectly;
+    private enqueuePendingMessage;
+    private tryStartRunnableQueueHead;
+    private tryConsumeWaitingQueue;
+    private interruptWaitingTurnWithMessage;
+    private startWaitingInterruptBatch;
+    private startImmediatePendingMessages;
+    private processPendingControlMessage;
+    private beginCompactTurn;
+    private refreshPendingMessagesBeforeStart;
+    private refreshPendingMessageBeforeStart;
+    private startTurnForMessages;
+    private beginGoalTurn;
+    private resolveThreadForMessage;
+    private profileForNewConversation;
+    private beginActiveTurn;
+    private replaceMissingThreadForActiveTurn;
+    private handleTurnStarted;
+    private handleSideTurnStarted;
+    private recordSideTokenUsageBestEffort;
+    private flushPendingSteers;
+    private handleRequestUserInput;
+    private handleSetThreadNameToolCall;
+    private handlePlanUpdated;
+    private finishActiveTurn;
+    private finishSideTurn;
+    private captureTurnEnd;
+    private clearPendingMessages;
+    private clearPendingMessagesBestEffort;
+    private cancelActiveTurn;
+    private cancelSideTurn;
+    private cancelAllSideTurns;
+    private failSideTurnForShutdown;
+    private failSideTurnsForShutdown;
+    private failSideTurnsForProfile;
+    private suspendActiveTurnForCodexAppServerExit;
+    private recoverSuspendedActiveTurnForCodexAppServerExit;
+    private suspendActiveTurnForShutdown;
+    private interruptActiveTurnBestEffort;
+    private clearActiveGoalBestEffort;
+    private unsubscribeSideThreadBestEffort;
+    private recordCodexThreadBestEffort;
+    private setThreadModeBestEffort;
+    private setThreadStatusBestEffort;
+    private recordOrReplaceCodexThreadBestEffort;
+    private renderThreadSummaryCard;
+    private handleCodexThreadNameUpdated;
+    private isMainConversationThread;
+    private applyThreadNameUpdate;
+    private syncCodexThreadNameBestEffort;
+    private logoImageKey;
+    private bannerImageKey;
+    private findActiveTurn;
+    private rememberPendingThreadName;
+    private consumePendingThreadName;
+    private updateThreadSummaryCardBestEffort;
+    private profileDefaultModelSettings;
+    private threadModelSettings;
+    private readCodexTurnModelSettingsBestEffort;
+    private readThreadTokenUsageBestEffort;
+    private resolveRecoveredUsageTarget;
+    private resolveFallbackUsageTargetMessageId;
+    private recordThreadTokenUsageBestEffort;
+    private recordLarkMessageTokenUsageBestEffort;
+    private patchActiveAgentCardTokenUsageBestEffort;
+    private markPendingMessagesProcessingBestEffort;
+    private markMessagesProcessingBestEffort;
+    private markActiveProcessingMessagesSteered;
+    private markMessagesSteeredBestEffort;
+    private markPendingMessagesQueuedBestEffort;
+    private markMessageRecalledBestEffort;
+    private updateQueuedMessageBestEffort;
+    private updateSideMessageMetadataBestEffort;
+    private markMessagesCompletedBestEffort;
+    private markMessagesFailedBestEffort;
+    private markMessagesInterruptedBestEffort;
+    private markPendingMessagesClearedBestEffort;
+    private getOrCreateConversation;
+    private resolveActiveThread;
+    private resumeThreadRecord;
+    private replaceThreadBindingBestEffort;
+    private getState;
+    private addReactionBestEffort;
+    private addQueuedReactionBestEffort;
+    private addQueuedReactionsBestEffort;
+    private clearQueuedReactionBestEffort;
+    private clearQueuedReactionsBestEffort;
+    private moveReactionBestEffort;
+    private clearReactionBestEffort;
+    private removeReactionBestEffort;
+    private canControlActiveTurn;
+    private canSteerActiveTurn;
+    private notifyThreadReplacementBestEffort;
+    private replyControlBestEffort;
+    private replyStatusCardBestEffort;
+    private sendEphemeralStatusCardBestEffort;
+    private sendDirectControlBestEffort;
+    private readCodexVersionBestEffort;
+    private recallMessageBestEffort;
+    private replyGroupUnauthorizedBestEffort;
+    private replyErrorBestEffort;
+    private replyAgentMessageForActiveBestEffort;
+    private recordImageGenerationForActiveBestEffort;
+    private updateAgentCardWithGeneratedImageBestEffort;
+    private updateAgentCardWithThreadNameBestEffort;
+    private recordGoalUpdateForActiveBestEffort;
+    private recordGoalClearedForActiveBestEffort;
+    private updateThreadGoalStatusBestEffort;
+    private clearThreadGoalStatusBestEffort;
+    private refreshThreadGoalStatusBestEffort;
+    private clearThreadGoalStatusAwaitBestEffort;
+    private goalNeedsResume;
+    private resumeGoalForActiveBestEffort;
+    private updateAgentCardWithMessageBestEffort;
+    private createAgentCardBestEffort;
+    private patchAgentCardBestEffort;
+    private notifyAgentCardBestEffort;
+    private completeAgentCardBestEffort;
+    private shouldUpdateCompletedAgentCardInPlace;
+    private updateCompletedAgentCardInPlace;
+    private resendCompletedAgentCard;
+    private replyAgentCardFilesBestEffort;
+    private failAgentCardBestEffort;
+    private patchRecoveredSideCardFailedBestEffort;
+    private interruptAgentCardBestEffort;
+    private pauseAgentCardForShutdownBestEffort;
+    private startAgentCardTimer;
+    private stopAgentCardTimer;
+    private moveAgentCardBestEffort;
+    private renderAgentCard;
+    private replyAgentMessageBestEffort;
+    private prepareAgentReplyForLark;
+    private prepareAgentFinalCardOutputForLark;
+}
+type LarkPostNode = {
+    tag: "md";
+    text: string;
+} | {
+    tag: "text";
+    text: string;
+} | {
+    tag: "at";
+    user_id: string;
+    user_name?: string;
+} | {
+    tag: "img";
+    image_key: string;
+} | {
+    tag: "media";
+    file_key: string;
+};
+type LarkPostContent = LarkPostNode[][];
+export {};