import type { Context } from "@deepseek-ai/cordis";
import { type Session, type SessionEvent } from "@deepseek-ai/dsh-session";
import { type ModelSelection } from "@deepseek-ai/dsh-agent";
import type { ChannelAdapter, InboundMessage, OutboundTarget } from "./types.js";
import { type NotifyLevel } from "./stream.js";
import { type MenuId } from "./menus.js";
import { type MenuHost } from "./menu-controller.js";
import type { BindingStore } from "./binding.js";
import { type Language, type Messages } from "./i18n.js";
import { type ReminderStore } from "./scheduler.js";
export interface ConnectConfig {
    /** Agent preset id composed into each session; `undefined` = roster default. */
    agentPreset?: string;
    /** Absolute working directory for each bound agent; defaults to process cwd. */
    workDir?: string;
    /** Optional workspace directories offered by the `/dir` chooser. */
    workspaces?: string[];
    /** Vision-capable model used to describe images when the main model can't. */
    visionModel?: {
        provider: string;
        model: string;
    };
    /** User-facing message language: `zh` (default) or `en`. */
    language?: Language;
    /** Fallback sender allowlist (open ids / user ids) for channels without their own. */
    allowUsers?: string[];
    /** Fallback chat allowlist for channels without their own. */
    allowChats?: string[];
    /**
     * Per-channel access control, keyed by channel id. A channel listed here uses
     * these lists *instead of* the top-level `allowUsers`/`allowChats`, because
     * identifiers are channel-specific and one global list cannot be right for two
     * channels at once.
     */
    channelAccess?: Record<string, {
        allowUsers?: string[];
        allowChats?: string[];
    }>;
    stateDir?: string;
    /** Automatically create Web mirror for new sessions (default: true). */
    autoMirror?: boolean;
    /** Liveness heartbeat interval ms for the streaming card; 0 disables it (default: 60000). */
    streamHeartbeatMs?: number;
    /** Streaming reply detail. Default 'result' (final answer only) keeps chat cards short. */
    notifyLevel?: NotifyLevel;
    /** Proactive progress-notice interval ms: when a turn goes silent for this long, a standalone status card is sent (default: 300000 = 5 min; 0 disables). */
    progressTimeoutMs?: number;
    /** Compact the session automatically once context usage crosses `autoCompactThresholdPct` (default: false). */
    autoCompact?: boolean;
    /** Context-window usage percentage that triggers `autoCompact` (default: 80). */
    autoCompactThresholdPct?: number;
    /**
     * How long a streaming card can be trusted to still exist (ms).
     *
     * Not user configuration — it is Feishu's ten-minute card lifetime. It lives here only so
     * a test can shorten it: the rule it gates applies to turns longer than ten minutes, and
     * a test that has to hold a turn open for ten real minutes would never be written.
     */
    cardLifetimeMs?: number;
}
export interface ResolvedConnectConfig {
    agentPreset?: string;
    workDir?: string;
    workspaces: string[];
    visionModel?: {
        provider: string;
        model: string;
    };
    language: Language;
    allowUsers: string[];
    allowChats: string[];
    /** Resolved per-channel access control; a missing channel falls back to the two above. */
    channelAccess: Record<string, {
        allowUsers: string[];
        allowChats: string[];
    }>;
    stateDir?: string;
    autoMirror: boolean;
    streamHeartbeatMs: number;
    notifyLevel: NotifyLevel;
    progressTimeoutMs: number;
    autoCompact: boolean;
    autoCompactThresholdPct: number;
    /** Test-only override of the streaming-card lifetime. See the ConnectConfig field. */
    cardLifetimeMs?: number;
}
export declare function resolveConnectConfig(config: ConnectConfig): ResolvedConnectConfig;
export declare class AgentRunner implements MenuHost {
    readonly ctx: Context;
    private readonly config;
    readonly channel: string;
    readonly chatKey: string;
    private readonly chatType;
    readonly adapter: ChannelAdapter;
    readonly bindings: BindingStore;
    private readonly adapters?;
    /**
     * Route a replayed queued message back into the runner of its own channel
     * (wired by ConnectService). Without it, replayed messages would run in
     * whichever runner happened to release the lock.
     */
    private readonly requeue?;
    /** Persistent chat-level reminders (`/remind`), wired by ConnectService. */
    private readonly reminders?;
    private readonly queue;
    private running;
    /**
     * Is a turn being driven by this runner right now?
     *
     * Used to route a question to the surface the user is actually typing in: a session can
     * be reachable from a chat and from the Web GUI mirror at once, and only the busy one is
     * where they are looking.
     */
    get isDrivingTurn(): boolean;
    /** Set by `dispose()`; makes the runner permanently inert. */
    private disposed;
    private agent?;
    private handle?;
    private turn?;
    workDir: string;
    language: Language;
    notifyLevel: NotifyLevel;
    progressTimeoutMs: number;
    /** Compact automatically once context usage crosses `autoCompactThresholdPct`. */
    autoCompact: boolean;
    /** Context-window usage percentage that triggers auto-compaction. */
    autoCompactThresholdPct: number;
    t: Messages;
    private readonly menu;
    constructor(ctx: Context, config: ResolvedConnectConfig, channel: string, chatKey: string, chatType: "p2p" | "group", adapter: ChannelAdapter, bindings: BindingStore, adapters?: Map<string, ChannelAdapter> | undefined, 
    /**
     * Route a replayed queued message back into the runner of its own channel
     * (wired by ConnectService). Without it, replayed messages would run in
     * whichever runner happened to release the lock.
     */
    requeue?: ((msg: InboundMessage) => void) | undefined, 
    /** Persistent chat-level reminders (`/remind`), wired by ConnectService. */
    reminders?: ReminderStore | undefined);
    menuTitle(menuId: MenuId): string;
    rootMenuSections(): readonly {
        title: string;
        ids: readonly string[];
        columnsPerRow?: number;
    }[];
    private reasonLabel;
    /** Prefer the user's first DSH workspace over the process cwd as default. */
    private resolveDefaultWorkDir;
    /**
     * Tear the runner down for good — the counterpoint to `enqueue`.
     *
     * Called when the runner's channel adapter is deactivated (a settings change
     * removed that channel from `channels[]`) or the service shuts down. The
     * runner is inert afterwards: `enqueue` drops work and the drain loop stops
     * before its next turn. `ConnectService` deletes its map entry, so a later
     * message builds a fresh runner instead of reviving this one.
     *
     * `queuedMessages` is cleared rather than replayed: those messages belong to
     * a channel that no longer has an adapter to answer on, so replaying them
     * would run agent turns whose output has nowhere to go.
     */
    dispose(): Promise<void>;
    enqueue(msg: InboundMessage): void;
    /** Route one live session event to the active turn's chunk queue. */
    onSessionEvent(session: Session, event: SessionEvent): void;
    /**
     * Show the subtask list, and keep it current in place.
     *
     * The first write posts the list; every later write edits that same message. Editing
     * rather than re-posting is the whole point — a plan that arrives as a new bubble every
     * time a step completes buries the conversation, and the user asked for the list to be
     * *updated*, not repeated.
     *
     * Runs at every notification level, for the same reason the progress reminder does: the
     * plan is not live activity chatter, it is the shape of the work, and a user who chose
     * a quiet level chose to stop hearing about individual tool calls — not to be left
     * guessing what the task actually consists of.
     */
    /**
     * Post the progress reminder, or rewrite the one already on screen.
     *
     * Reported from a turn left running overnight: 「一晚上会堆积无数的提醒」. The watchdog was
     * appending a fresh message every interval, so a 13.6-hour turn produced over 160
     * near-identical bubbles — each one repeating the elapsed time and the current milestone.
     * The information in the last one supersedes every earlier one, which makes the earlier
     * ones pure noise.
     *
     * The first notice posts and remembers its id; every later one rewrites that message. A
     * channel that cannot edit text keeps posting, which is the old behaviour rather than a
     * regression — and if the edit fails the id is dropped so the next notice starts a fresh
     * message instead of editing something that no longer exists.
     */
    private publishProgressNotice;
    /**
     * The list body plus the time it was last accurate.
     *
     * Measured on a real session: the agent calls `todo_write` rarely — one stretch had 224
     * tool calls between writes, with the card showing "0 done" throughout. The card was not
     * wrong, it was *old*: it can only reflect what the agent last reported, and the agent
     * does not re-report after every step. The user read that as "the progress stopped
     * updating" (「实际可能已经到了第5步」), which is the reasonable reading of a live-looking
     * list that is an hour out of date.
     *
     * So the card says how old it is. What it must NOT do is guess: inferring progress from
     * tool activity would mean inventing which step a tool call belongs to, and a plan that
     * states a status the agent never reported is worse than one that admits its age.
     */
    private subtaskBody;
    private publishSubtasks;
    /**
     * Proactive context-high nudge: when the turn's observed context usage
     * crosses the compaction threshold, ask the user (once per turn) whether to
     * compact now, instead of waiting until the turn ends to report it.
     */
    private maybeNudgeContext;
    private target;
    /** Completion-card target: in groups, @ the requester so they notice the result. */
    private taskTarget;
    /** Send the one-time welcome card on a chat's first message (persisted marker). */
    private maybeSendWelcome;
    /** Pick the localized advice text for a failed turn. */
    private errorAdvice;
    /** Present a destructive-action confirmation; true only when the user confirms. */
    confirmAction(target: OutboundTarget, promptText: string, messageId?: string): Promise<boolean>;
    private drain;
    private runTurn;
    private ensureAgent;
    /**
     * Attach a session to the DSH workspace matching its work directory so the
     * Web GUI groups it under the same workspace the Feishu side uses.
     * Best-effort: without a workspace registry this is a no-op.
     */
    private attachToWorkspace;
    /**
     * Historical sessions for the CURRENT work directory: this chat's binding
     * records (filtered by workDir), then any other session the DSH workspace
     * registry attaches to the directory (e.g. Web-created or older-chat
     * sessions). Titles come from the binding record when known, otherwise from
     * the host's session title service. Sorted newest first.
     */
    collectWorkdirSessions(): Promise<{
        sessionId: string;
        title: string;
    }[]>;
    /**
     * Session ids the DSH workspace registry attaches to a work directory.
     * Best-effort: without a workspace registry this returns `[]`.
     */
    private workspaceSessionIds;
    /** Latest display title of a session via the host query service, or undefined. */
    private sessionTitleOf;
    private get agents();
    private get sessions();
    defaultSelection(): ModelSelection;
    /**
     * Compose the preset-only agent setup.
     *
     * Deliberately does NOT install a static model selection on the agent. The
     * DSH Web GUI switches models through the host api-proxy's session-scoped
     * selection (`selectionFor` + `installModelSelection`), which is installed
     * lazily when a session's model directory is loaded and wins the
     * `agent/request` waterfall. A static selection captured here at create /
     * resume time would take precedence over that and silently pin every request
     * to the default model captured at composition — so a model the user picks
     * in the Web GUI would appear to succeed (the seat and `session.models`
     * report it) while the actual LLM requests keep using the old default.
     * The default model still seeds the agent through `agentOptions` in
     * `ensureAgent`, which `buildRequest` uses as its fallback route.
     *
     * Preset resolution is best-effort — see {@link resolvePresetId}. This method
     * never throws for a preset reason, so no configuration id can stop a turn
     * from composing an agent at all.
     */
    private composeSetup;
    /**
     * Resolve the preset to compose, degrading instead of aborting the turn.
     *
     * The host looks a preset up by id, so one stale id — `agentPresets.default`
     * naming a preset this install does not ship, or a preset directory edited
     * into an unreadable state — used to throw straight out of `composeSetup`.
     * That happens before an agent exists, so *every* turn of every bound chat
     * died with the raw host error and nothing in the session log to explain it.
     * Resolution is therefore best-effort: the configured id is tried, then
     * {@link FALLBACK_PRESET_ID}, and when neither composes the agent is built
     * without a preset — the same shape a host with no `agentPresets` service
     * already produced — so the turn still runs.
     */
    private resolvePresetId;
    /**
     * Resolve `id`, reporting why it is unusable instead of throwing.
     *
     * A preset that resolves but reports `broken` counts as unusable: the host's
     * mounting paths refuse those, so composing one would only move this failure
     * to `mount`, after the log line that would have explained it.
     *
     * `undefined` id means "the roster default", which is what `resolve` does
     * with it — the default is as fallible as an explicit id, so it is routed
     * through the same recovery.
     */
    private tryPreset;
    /**
     * The id to retry with: {@link FALLBACK_PRESET_ID} while the roster still
     * offers it, otherwise the roster's first mountable row.
     *
     * Never throws — the caller is already handling a failure, and a roster that
     * cannot be listed should still leave the hardcoded id to be tried.
     */
    private fallbackPresetId;
    /** Agents this runner has already attached a `session/event` listener to. */
    private readonly watchedAgents;
    private watchAgent;
    private driveAgent;
    /**
     * Build the user content for one inbound message. When the message carries
     * images, either pass them directly to the main model (if it supports
     * vision) or run a vision sub-task with a capable model and inject its
     * description as text — so a text-only main model never stalls on images.
     */
    private buildUserContent;
    /** Copy images into `<workDir>/.dsh-connect-images` so the agent's tools can reach them. */
    private stageImages;
    /** Copy non-image attachments into `<workDir>/.dsh-connect-files` so the agent's tools can reach them. */
    private stageFiles;
    private imageBlocks;
    private describeImages;
    private modelSupportsVision;
    private findVisionModel;
    private log;
    private warn;
    /**
     * Send a task-end card and report a delivery failure instead of discarding it.
     *
     * The catch used to be a bare `undefined`, which made a dropped card and a card
     * with nothing to say indistinguishable. It is neither: this card is the
     * durable record of the turn — the result text and the token/duration summary —
     * and the streaming card it replaces is meanwhile stuck on its last frame. A
     * silent failure here leaves the user watching a frozen "running" indicator
     * with no reason to think anything went wrong.
     *
     * The log is the only report available: the user-facing channel is precisely
     * what just failed, so there is nothing to send the notice on.
     */
    private sendTaskCard;
    private readTodos;
    private touchBinding;
    private sendSummary;
    /** Context-window usage at or above this percentage suggests compaction. */
    /**
     * How long a streaming card can be trusted to still exist.
     *
     * Feishu closes a streaming card ten minutes after it is created — stated three times in
     * the Lark SDK's own comments ("Feishu auto-closes after 10min"). Treated as a hard
     * boundary here because edits to a closed card are accepted by the API and then simply
     * not shown, which is the worst failure mode available: no error, no log, no update.
     *
     * The value is deliberately the conservative reading of the documented figure.
     */
    private static readonly CARD_LIFETIME_MS;
    /**
     * The card lifetime this runner uses.
     *
     * Overridable so the behaviour can be tested without holding a turn open for ten real
     * minutes — a rule that only shows up on long turns is exactly the kind that goes
     * untested, and this one already shipped broken once. The override is not exposed as
     * user configuration: it is a Feishu platform constant, not a preference.
     */
    private readonly cardLifetimeMs;
    private static readonly COMPACT_THRESHOLD_PCT;
    /**
     * Send a compact task-end card: the model used, input/output tokens, elapsed
     * time, and whether compaction is advisable given context-window usage.
     */
    private sendTurnStats;
    private handleCommand;
    private disposeAgent;
    /**
     * `/ps <note>` — append a note to the running task. Uses the agent's `steer`
     * inbox: a running driver consumes the note at its next step boundary (so it
     * steers the in-flight task), and an idle driver starts a new turn with it.
     */
    private handleAppend;
    /**
     * `/remind <time> <text>` — persist a chat-level reminder that fires
     * without waking the agent (see src/scheduler.ts).
     */
    private handleRemind;
    /**
     * `/send <path>` — deliver a file from the workspace through the channel's
     * `sendFile` capability; falls back to sending the path as text.
     */
    private handleSend;
    /**
     * `/broadcast <text>` — admins push a message to every bound chat.
     * Admin gating lives in the connect service (allowUsers).
     */
    private handleBroadcast;
    private recordSession;
    /**
     * Automatically create a Web mirror for the session.
     * This enables DSH Web GUI to view and interact with the conversation
     * without requiring manual `/mirror` command.
     */
    private autoCreateWebMirror;
    newChat(msg: InboundMessage): Promise<void>;
    private clearChat;
    switchTo(sessionId: string, ownerKey: string): Promise<void>;
    listWorkspaces(): {
        path: string;
        title: string;
    }[];
    showStatus(target: OutboundTarget): Promise<void>;
    /** Extract the most recent turn's completion info from session events. */
    private getLastTurnInfo;
    showTasks(target: OutboundTarget): Promise<void>;
    showSettings(target: OutboundTarget): Promise<void>;
    setModel(provider: string, model: string, msg: InboundMessage): Promise<void>;
    setReasoning(effort: string | undefined, msg: InboundMessage): Promise<void>;
    /** Switch the user-facing language for this chat, persisted in its binding. */
    setLanguage(lang: Language, target: OutboundTarget, msg: InboundMessage): Promise<void>;
    /**
     * Switch the notification level for this chat (persisted in its binding and
     * effective immediately for the next streaming reply).
     */
    setNotifyLevel(level: NotifyLevel, target: OutboundTarget, msg: InboundMessage): Promise<void>;
    /**
     * `/autocompact [on|off|<1-99>]` — turn automatic context compaction on or
     * off for this chat, and set the threshold. A bare invocation reports the
     * current state instead of guessing, since the switch is a safety behaviour
     * and a typo silently disabling it would be the wrong default.
     */
    private handleAutocompact;
    /**
     * Persist the per-chat auto-compaction switch and/or threshold. Passing no
     * `pct` leaves the threshold alone, so `/autocompact on` does not silently
     * reset a threshold the user set earlier.
     */
    setAutoCompact(on: boolean, target: OutboundTarget, pct?: number): Promise<void>;
    /** Show the three-level notification picker (used by the `/notify` command). */
    private openNotifyPicker;
    /**
     * Switch the proactive progress-notice interval for this chat (persisted in
     * its binding and effective for the next turn; 0 disables the watchdog).
     */
    setProgressTimeout(ms: number, target: OutboundTarget, msg: InboundMessage): Promise<void>;
    /** Show the progress-interval picker (used by the `/progress` command). */
    private openProgressPicker;
    showPlugins(target: OutboundTarget): Promise<void>;
    private createWorkspace;
    /**
     * Compact the session automatically when context usage has reached
     * `autoCompactThresholdPct`, if the user turned `autoCompact` on.
     *
     * Deliberately silent on the happy path. Compaction is maintenance the user
     * asked to happen on its own, and a chat message every time it fires would be
     * exactly the kind of chatter the `important` level exists to suppress —
     * the chosen notification level governs this notice too. The turn-end stats
     * card reports the resulting usage either way, so the effect is visible
     * without an extra bubble; a *failure* is still reported, because silently
     * not compacting would leave the user believing they are protected.
     *
     * @param agent - the agent whose session may be compacted (must be idle).
     * @param msg - the inbound message, used to resolve the reply target.
     */
    private maybeAutoCompact;
    /**
     * Run DSH's compaction service against an idle agent.
     * @returns `compacted`, `nothing` (nothing to compact), or `unavailable`.
     */
    private runCompaction;
    /**
     * When the current stretch of work began, kept on the runner rather than only on
     * the turn object.
     *
     * The turn is discarded when `driveAgent` returns, but the agent can still be
     * busy — and the progress reminder needs an elapsed time it can trust even then.
     * Without this the fallback could only guess, and a reminder that reports the
     * wrong duration is worse than one that admits it has none.
     */
    /**
     * The subtask list message for the current decomposition, so later writes edit it
     * instead of posting again. Cleared when the edit fails, which means the card is gone.
     */
    private subtasksMessageId?;
    /** Identity of the rendered subtask list, so an unchanged plan costs no API call. */
    private lastSubtasksKey?;
    /** True while the initial post is in flight, so concurrent writes cannot post again. */
    private subtasksPosting;
    /**
     * The message currently carrying the progress reminder, so the next one rewrites it
     * instead of appending. Cleared when an edit fails, which means the message is gone.
     */
    private progressNoticeId?;
    /** The newest state seen while that post was in flight, replayed when it lands. */
    private subtasksPending?;
    private workStartedAt?;
    /** Latest milestone, mirrored off the turn so a reminder can report it after turn state is gone. */
    private lastMilestone?;
    /** Latest observed context usage, kept across turns so auto-compaction has a measurement. */
    private lastContextSize?;
    /** Latest observed context window, kept across turns so auto-compaction has a measurement. */
    private lastContextWindow?;
    compact(target: OutboundTarget): Promise<void>;
    showHistory(target: OutboundTarget, limit: number): Promise<void>;
    showGoals(target: OutboundTarget): Promise<void>;
    private goalPhaseLabel;
    showSchedule(target: OutboundTarget): Promise<void>;
    private showAllWorkspaces;
    /**
     * Create or show Web mirror session for this chat.
     * The mirror shares the same DSH session but enforces mutual exclusion:
     * when Feishu is executing a task, Web is read-only, and vice versa.
     */
    private handleMirror;
    /**
     * Manually release session lock.
     */
    private handleUnlock;
    /**
     * Renew the current session lock timeout.
     * Extends the lock by another full timeout period from now.
     */
    private handleRenewLock;
    /**
     * Export conversation history as Markdown (a future PDF pipeline can be
     * added here; `/export pdf` currently falls back to Markdown).
     */
    private handleExport;
    /**
     * Generate Markdown representation of the conversation history.
     */
    private generateMarkdown;
    /**
     * Check if the current channel has write access to the session.
     * Returns true if allowed to send messages, false if read-only.
     */
    private canWrite;
    /**
     * Acquire session lock for the given channel.
     * Returns true if lock acquired, false if already locked by another channel.
     */
    private acquireLock;
    /**
     * Queue a message for later execution when lock is released.
     * Returns the position in queue.
     */
    private queueMessage;
    /**
     * Process all queued messages after lock release.
     * Re-enqueues them into the runner's message queue for actual execution.
     */
    private processQueuedMessages;
    /**
     * Release session lock. Awaits the queued-message drain, then clears the
     * lock from a FRESH read: the drain's queue-clearing put must not be
     * overwritten by a stale binding object (which would resurrect the queue
     * and cause duplicate processing on the next release).
     */
    private releaseLock;
    /** Check and release timed-out locks (delegates to the pure lock module). */
    private checkAndReleaseTimeoutLock;
    /** Release a timed-out lock and notify. */
    private releaseTimeoutLock;
}
//# sourceMappingURL=runner.d.ts.map