skykoi 2026.3.21 → 2026.3.23

package/dist/plugin-sdk/auto-reply/reply/block-reply-coalescer.d.ts

@@ -0,0 +1,15 @@
+import type { ReplyPayload } from "../types.js";
+import type { BlockStreamingCoalescing } from "./block-streaming.js";
+export type BlockReplyCoalescer = {
+    enqueue: (payload: ReplyPayload) => void;
+    flush: (options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    hasBuffered: () => boolean;
+    stop: () => void;
+};
+export declare function createBlockReplyCoalescer(params: {
+    config: BlockStreamingCoalescing;
+    shouldAbort: () => boolean;
+    onFlush: (payload: ReplyPayload) => Promise<void> | void;
+}): BlockReplyCoalescer;

package/dist/plugin-sdk/auto-reply/reply/block-reply-pipeline.d.ts

@@ -0,0 +1,31 @@
+import type { ReplyPayload } from "../types.js";
+import type { BlockStreamingCoalescing } from "./block-streaming.js";
+export type BlockReplyPipeline = {
+    enqueue: (payload: ReplyPayload) => void;
+    flush: (options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    stop: () => void;
+    hasBuffered: () => boolean;
+    didStream: () => boolean;
+    isAborted: () => boolean;
+    hasSentPayload: (payload: ReplyPayload) => boolean;
+};
+export type BlockReplyBuffer = {
+    shouldBuffer: (payload: ReplyPayload) => boolean;
+    onEnqueue?: (payload: ReplyPayload) => void;
+    finalize?: (payload: ReplyPayload) => ReplyPayload;
+};
+export declare function createAudioAsVoiceBuffer(params: {
+    isAudioPayload: (payload: ReplyPayload) => boolean;
+}): BlockReplyBuffer;
+export declare function createBlockReplyPayloadKey(payload: ReplyPayload): string;
+export declare function createBlockReplyPipeline(params: {
+    onBlockReply: (payload: ReplyPayload, options?: {
+        abortSignal?: AbortSignal;
+        timeoutMs?: number;
+    }) => Promise<void> | void;
+    timeoutMs: number;
+    coalescing?: BlockStreamingCoalescing;
+    buffer?: BlockReplyBuffer;
+}): BlockReplyPipeline;

package/dist/plugin-sdk/auto-reply/reply/block-streaming.d.ts

@@ -0,0 +1,22 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+export type BlockStreamingCoalescing = {
+    minChars: number;
+    maxChars: number;
+    idleMs: number;
+    joiner: string;
+    /** When true, the coalescer flushes the buffer on each enqueue (paragraph-boundary flush). */
+    flushOnEnqueue?: boolean;
+};
+export declare function resolveBlockStreamingChunking(cfg: SKYKOIConfig | undefined, provider?: string, accountId?: string | null): {
+    minChars: number;
+    maxChars: number;
+    breakPreference: "paragraph" | "newline" | "sentence";
+    flushOnParagraph?: boolean;
+};
+export declare function resolveBlockStreamingCoalescing(cfg: SKYKOIConfig | undefined, provider?: string, accountId?: string | null, chunking?: {
+    minChars: number;
+    maxChars: number;
+    breakPreference: "paragraph" | "newline" | "sentence";
+}, opts?: {
+    chunkMode?: "length" | "newline";
+}): BlockStreamingCoalescing | undefined;

package/dist/plugin-sdk/auto-reply/reply/body.d.ts

@@ -0,0 +1,11 @@
+import type { SessionEntry } from "../../config/sessions.js";
+export declare function applySessionHints(params: {
+    baseBody: string;
+    abortedLastRun: boolean;
+    sessionEntry?: SessionEntry;
+    sessionStore?: Record<string, SessionEntry>;
+    sessionKey?: string;
+    storePath?: string;
+    abortKey?: string;
+    messageId?: string;
+}): Promise<string>;

package/dist/plugin-sdk/auto-reply/reply/commands-allowlist.d.ts

@@ -0,0 +1,2 @@
+import type { CommandHandler } from "./commands-types.js";
+export declare const handleAllowlistCommand: CommandHandler;

package/dist/plugin-sdk/auto-reply/reply/commands-approve.d.ts

@@ -0,0 +1,2 @@
+import type { CommandHandler } from "./commands-types.js";
+export declare const handleApproveCommand: CommandHandler;

package/dist/plugin-sdk/auto-reply/reply/commands-bash.d.ts

@@ -0,0 +1,2 @@
+import type { CommandHandler } from "./commands-types.js";
+export declare const handleBashCommand: CommandHandler;

package/dist/plugin-sdk/auto-reply/reply/commands-compact.d.ts

@@ -0,0 +1,2 @@
+import type { CommandHandler } from "./commands-types.js";
+export declare const handleCompactCommand: CommandHandler;

package/dist/plugin-sdk/auto-reply/reply/commands-config.d.ts

@@ -0,0 +1,3 @@
+import type { CommandHandler } from "./commands-types.js";
+export declare const handleConfigCommand: CommandHandler;
+export declare const handleDebugCommand: CommandHandler;

package/dist/plugin-sdk/auto-reply/reply/commands-context-report.d.ts

@@ -0,0 +1,3 @@
+import type { ReplyPayload } from "../types.js";
+import type { HandleCommandsParams } from "./commands-types.js";
+export declare function buildContextReply(params: HandleCommandsParams): Promise<ReplyPayload>;

package/dist/plugin-sdk/auto-reply/reply/commands-context.d.ts

@@ -0,0 +1,12 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { MsgContext } from "../templating.js";
+import type { CommandContext } from "./commands-types.js";
+export declare function buildCommandContext(params: {
+    ctx: MsgContext;
+    cfg: SKYKOIConfig;
+    agentId?: string;
+    sessionKey?: string;
+    isGroup: boolean;
+    triggerBodyNormalized: string;
+    commandAuthorized: boolean;
+}): CommandContext;

package/dist/plugin-sdk/auto-reply/reply/commands-core.d.ts

@@ -0,0 +1,2 @@
+import type { CommandHandlerResult, HandleCommandsParams } from "./commands-types.js";
+export declare function handleCommands(params: HandleCommandsParams): Promise<CommandHandlerResult>;

package/dist/plugin-sdk/auto-reply/reply/commands-info.d.ts

@@ -0,0 +1,10 @@
+import type { CommandHandler } from "./commands-types.js";
+export declare const handleHelpCommand: CommandHandler;
+export declare const handleCommandsListCommand: CommandHandler;
+export declare function buildCommandsPaginationKeyboard(currentPage: number, totalPages: number, agentId?: string): Array<Array<{
+    text: string;
+    callback_data: string;
+}>>;
+export declare const handleStatusCommand: CommandHandler;
+export declare const handleContextCommand: CommandHandler;
+export declare const handleWhoamiCommand: CommandHandler;

package/dist/plugin-sdk/auto-reply/reply/commands-models.d.ts

@@ -0,0 +1,23 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { ReplyPayload } from "../types.js";
+import type { CommandHandler } from "./commands-types.js";
+export type ModelsProviderData = {
+    byProvider: Map<string, Set<string>>;
+    providers: string[];
+    resolvedDefault: {
+        provider: string;
+        model: string;
+    };
+};
+/**
+ * Build provider/model data from config and catalog.
+ * Exported for reuse by callback handlers.
+ */
+export declare function buildModelsProviderData(cfg: SKYKOIConfig): Promise<ModelsProviderData>;
+export declare function resolveModelsCommandReply(params: {
+    cfg: SKYKOIConfig;
+    commandBodyNormalized: string;
+    surface?: string;
+    currentModel?: string;
+}): Promise<ReplyPayload | null>;
+export declare const handleModelsCommand: CommandHandler;

package/dist/plugin-sdk/auto-reply/reply/commands-plugin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Plugin Command Handler
+ *
+ * Handles commands registered by plugins, bypassing the LLM agent.
+ * This handler is called before built-in command handlers.
+ */
+import type { CommandHandler } from "./commands-types.js";
+/**
+ * Handle plugin-registered commands.
+ * Returns a result if a plugin command was matched and executed,
+ * or null to continue to the next handler.
+ */
+export declare const handlePluginCommand: CommandHandler;

package/dist/plugin-sdk/auto-reply/reply/commands-session.d.ts

@@ -0,0 +1,7 @@
+import type { CommandHandler } from "./commands-types.js";
+export declare const handleActivationCommand: CommandHandler;
+export declare const handleSendPolicyCommand: CommandHandler;
+export declare const handleUsageCommand: CommandHandler;
+export declare const handleRestartCommand: CommandHandler;
+export declare const handleStopCommand: CommandHandler;
+export declare const handleAbortTrigger: CommandHandler;

package/dist/plugin-sdk/auto-reply/reply/commands-status.d.ts

@@ -0,0 +1,24 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { SessionEntry, SessionScope } from "../../config/sessions.js";
+import type { MediaUnderstandingDecision } from "../../media-understanding/types.js";
+import type { ElevatedLevel, ReasoningLevel, ThinkLevel, VerboseLevel } from "../thinking.js";
+import type { ReplyPayload } from "../types.js";
+import type { CommandContext } from "./commands-types.js";
+export declare function buildStatusReply(params: {
+    cfg: SKYKOIConfig;
+    command: CommandContext;
+    sessionEntry?: SessionEntry;
+    sessionKey: string;
+    sessionScope?: SessionScope;
+    provider: string;
+    model: string;
+    contextTokens: number;
+    resolvedThinkLevel?: ThinkLevel;
+    resolvedVerboseLevel: VerboseLevel;
+    resolvedReasoningLevel: ReasoningLevel;
+    resolvedElevatedLevel?: ElevatedLevel;
+    resolveDefaultThinkingLevel: () => Promise<ThinkLevel | undefined>;
+    isGroup: boolean;
+    defaultGroupActivation: () => "always" | "mention";
+    mediaDecisions?: MediaUnderstandingDecision[];
+}): Promise<ReplyPayload | undefined>;

package/dist/plugin-sdk/auto-reply/reply/commands-subagents.d.ts

@@ -0,0 +1,13 @@
+import type { CommandHandler } from "./commands-types.js";
+type ChatMessage = {
+    role?: unknown;
+    content?: unknown;
+    name?: unknown;
+    toolName?: unknown;
+};
+export declare function extractMessageText(message: ChatMessage): {
+    role: string;
+    text: string;
+} | null;
+export declare const handleSubagentsCommand: CommandHandler;
+export {};

package/dist/plugin-sdk/auto-reply/reply/commands-tts.d.ts

@@ -0,0 +1,2 @@
+import type { CommandHandler } from "./commands-types.js";
+export declare const handleTtsCommands: CommandHandler;

package/dist/plugin-sdk/auto-reply/reply/commands-types.d.ts

@@ -0,0 +1,60 @@
+import type { SkillCommandSpec } from "../../agents/skills.js";
+import type { ChannelId } from "../../channels/plugins/types.js";
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { SessionEntry, SessionScope } from "../../config/sessions.js";
+import type { MsgContext } from "../templating.js";
+import type { ElevatedLevel, ReasoningLevel, ThinkLevel, VerboseLevel } from "../thinking.js";
+import type { ReplyPayload } from "../types.js";
+import type { InlineDirectives } from "./directive-handling.js";
+export type CommandContext = {
+    surface: string;
+    channel: string;
+    channelId?: ChannelId;
+    ownerList: string[];
+    senderIsOwner: boolean;
+    isAuthorizedSender: boolean;
+    senderId?: string;
+    abortKey?: string;
+    rawBodyNormalized: string;
+    commandBodyNormalized: string;
+    from?: string;
+    to?: string;
+};
+export type HandleCommandsParams = {
+    ctx: MsgContext;
+    cfg: SKYKOIConfig;
+    command: CommandContext;
+    agentId?: string;
+    directives: InlineDirectives;
+    elevated: {
+        enabled: boolean;
+        allowed: boolean;
+        failures: Array<{
+            gate: string;
+            key: string;
+        }>;
+    };
+    sessionEntry?: SessionEntry;
+    previousSessionEntry?: SessionEntry;
+    sessionStore?: Record<string, SessionEntry>;
+    sessionKey: string;
+    storePath?: string;
+    sessionScope?: SessionScope;
+    workspaceDir: string;
+    defaultGroupActivation: () => "always" | "mention";
+    resolvedThinkLevel?: ThinkLevel;
+    resolvedVerboseLevel: VerboseLevel;
+    resolvedReasoningLevel: ReasoningLevel;
+    resolvedElevatedLevel?: ElevatedLevel;
+    resolveDefaultThinkingLevel: () => Promise<ThinkLevel | undefined>;
+    provider: string;
+    model: string;
+    contextTokens: number;
+    isGroup: boolean;
+    skillCommands?: SkillCommandSpec[];
+};
+export type CommandHandlerResult = {
+    reply?: ReplyPayload;
+    shouldContinue: boolean;
+};
+export type CommandHandler = (params: HandleCommandsParams, allowTextCommands: boolean) => Promise<CommandHandlerResult | null>;

package/dist/plugin-sdk/auto-reply/reply/commands.d.ts

@@ -0,0 +1,4 @@
+export { buildCommandContext } from "./commands-context.js";
+export { handleCommands } from "./commands-core.js";
+export { buildStatusReply } from "./commands-status.js";
+export type { CommandContext, CommandHandlerResult, HandleCommandsParams, } from "./commands-types.js";

package/dist/plugin-sdk/auto-reply/reply/config-commands.d.ts

@@ -0,0 +1,15 @@
+export type ConfigCommand = {
+    action: "show";
+    path?: string;
+} | {
+    action: "set";
+    path: string;
+    value: unknown;
+} | {
+    action: "unset";
+    path: string;
+} | {
+    action: "error";
+    message: string;
+};
+export declare function parseConfigCommand(raw: string): ConfigCommand | null;

package/dist/plugin-sdk/auto-reply/reply/config-value.d.ts

@@ -0,0 +1,4 @@
+export declare function parseConfigValue(raw: string): {
+    value?: unknown;
+    error?: string;
+};

package/dist/plugin-sdk/auto-reply/reply/debug-commands.d.ts

@@ -0,0 +1,16 @@
+export type DebugCommand = {
+    action: "show";
+} | {
+    action: "reset";
+} | {
+    action: "set";
+    path: string;
+    value: unknown;
+} | {
+    action: "unset";
+    path: string;
+} | {
+    action: "error";
+    message: string;
+};
+export declare function parseDebugCommand(raw: string): DebugCommand | null;

package/dist/plugin-sdk/auto-reply/reply/directive-handling.auth.d.ts

@@ -0,0 +1,19 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+export type ModelAuthDetailMode = "compact" | "verbose";
+export declare const resolveAuthLabel: (provider: string, cfg: SKYKOIConfig, modelsPath: string, agentDir?: string, mode?: ModelAuthDetailMode) => Promise<{
+    label: string;
+    source: string;
+}>;
+export declare const formatAuthLabel: (auth: {
+    label: string;
+    source: string;
+}) => string;
+export declare const resolveProfileOverride: (params: {
+    rawProfile?: string;
+    provider: string;
+    cfg: SKYKOIConfig;
+    agentDir?: string;
+}) => {
+    profileId?: string;
+    error?: string;
+};

package/dist/plugin-sdk/auto-reply/reply/directive-handling.d.ts

@@ -0,0 +1,6 @@
+export { applyInlineDirectivesFastLane } from "./directive-handling.fast-lane.js";
+export * from "./directive-handling.impl.js";
+export type { InlineDirectives } from "./directive-handling.parse.js";
+export { isDirectiveOnly, parseInlineDirectives } from "./directive-handling.parse.js";
+export { persistInlineDirectives, resolveDefaultModel } from "./directive-handling.persist.js";
+export { formatDirectiveAck } from "./directive-handling.shared.js";

package/dist/plugin-sdk/auto-reply/reply/directive-handling.fast-lane.d.ts

@@ -0,0 +1,47 @@
+import type { ModelAliasIndex } from "../../agents/model-selection.js";
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { SessionEntry } from "../../config/sessions.js";
+import type { MsgContext } from "../templating.js";
+import type { ReplyPayload } from "../types.js";
+import type { InlineDirectives } from "./directive-handling.parse.js";
+import type { ThinkLevel } from "./directives.js";
+export declare function applyInlineDirectivesFastLane(params: {
+    directives: InlineDirectives;
+    commandAuthorized: boolean;
+    ctx: MsgContext;
+    cfg: SKYKOIConfig;
+    agentId?: string;
+    isGroup: boolean;
+    sessionEntry: SessionEntry;
+    sessionStore: Record<string, SessionEntry>;
+    sessionKey: string;
+    storePath?: string;
+    elevatedEnabled: boolean;
+    elevatedAllowed: boolean;
+    elevatedFailures?: Array<{
+        gate: string;
+        key: string;
+    }>;
+    messageProviderKey?: string;
+    defaultProvider: string;
+    defaultModel: string;
+    aliasIndex: ModelAliasIndex;
+    allowedModelKeys: Set<string>;
+    allowedModelCatalog: Awaited<ReturnType<typeof import("../../agents/model-catalog.js").loadModelCatalog>>;
+    resetModelOverride: boolean;
+    provider: string;
+    model: string;
+    initialModelLabel: string;
+    formatModelSwitchEvent: (label: string, alias?: string) => string;
+    agentCfg?: NonNullable<SKYKOIConfig["agents"]>["defaults"];
+    modelState: {
+        resolveDefaultThinkingLevel: () => Promise<ThinkLevel | undefined>;
+        allowedModelKeys: Set<string>;
+        allowedModelCatalog: Awaited<ReturnType<typeof import("../../agents/model-catalog.js").loadModelCatalog>>;
+        resetModelOverride: boolean;
+    };
+}): Promise<{
+    directiveAck?: ReplyPayload;
+    provider: string;
+    model: string;
+}>;

package/dist/plugin-sdk/auto-reply/reply/directive-handling.impl.d.ts

@@ -0,0 +1,36 @@
+import type { ModelAliasIndex } from "../../agents/model-selection.js";
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { ReplyPayload } from "../types.js";
+import type { InlineDirectives } from "./directive-handling.parse.js";
+import type { ElevatedLevel, ReasoningLevel, ThinkLevel, VerboseLevel } from "./directives.js";
+import { type SessionEntry } from "../../config/sessions.js";
+export declare function handleDirectiveOnly(params: {
+    cfg: SKYKOIConfig;
+    directives: InlineDirectives;
+    sessionEntry: SessionEntry;
+    sessionStore: Record<string, SessionEntry>;
+    sessionKey: string;
+    storePath?: string;
+    elevatedEnabled: boolean;
+    elevatedAllowed: boolean;
+    elevatedFailures?: Array<{
+        gate: string;
+        key: string;
+    }>;
+    messageProviderKey?: string;
+    defaultProvider: string;
+    defaultModel: string;
+    aliasIndex: ModelAliasIndex;
+    allowedModelKeys: Set<string>;
+    allowedModelCatalog: Awaited<ReturnType<typeof import("../../agents/model-catalog.js").loadModelCatalog>>;
+    resetModelOverride: boolean;
+    provider: string;
+    model: string;
+    initialModelLabel: string;
+    formatModelSwitchEvent: (label: string, alias?: string) => string;
+    currentThinkLevel?: ThinkLevel;
+    currentVerboseLevel?: VerboseLevel;
+    currentReasoningLevel?: ReasoningLevel;
+    currentElevatedLevel?: ElevatedLevel;
+    surface?: string;
+}): Promise<ReplyPayload | undefined>;

package/dist/plugin-sdk/auto-reply/reply/directive-handling.model-picker.d.ts

@@ -0,0 +1,13 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import { type ModelRef } from "../../agents/model-selection.js";
+export type ModelPickerCatalogEntry = {
+    provider: string;
+    id: string;
+    name?: string;
+};
+export type ModelPickerItem = ModelRef;
+export declare function buildModelPickerItems(catalog: ModelPickerCatalogEntry[]): ModelPickerItem[];
+export declare function resolveProviderEndpointLabel(provider: string, cfg: SKYKOIConfig): {
+    endpoint?: string;
+    api?: string;
+};

package/dist/plugin-sdk/auto-reply/reply/directive-handling.model.d.ts

@@ -0,0 +1,42 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { ReplyPayload } from "../types.js";
+import type { InlineDirectives } from "./directive-handling.parse.js";
+import { type ModelAliasIndex } from "../../agents/model-selection.js";
+import { type ModelDirectiveSelection } from "./model-selection.js";
+export declare function maybeHandleModelDirectiveInfo(params: {
+    directives: InlineDirectives;
+    cfg: SKYKOIConfig;
+    agentDir: string;
+    activeAgentId: string;
+    provider: string;
+    model: string;
+    defaultProvider: string;
+    defaultModel: string;
+    aliasIndex: ModelAliasIndex;
+    allowedModelCatalog: Array<{
+        provider: string;
+        id?: string;
+        name?: string;
+    }>;
+    resetModelOverride: boolean;
+    surface?: string;
+}): Promise<ReplyPayload | undefined>;
+export declare function resolveModelSelectionFromDirective(params: {
+    directives: InlineDirectives;
+    cfg: SKYKOIConfig;
+    agentDir: string;
+    defaultProvider: string;
+    defaultModel: string;
+    aliasIndex: ModelAliasIndex;
+    allowedModelKeys: Set<string>;
+    allowedModelCatalog: Array<{
+        provider: string;
+        id?: string;
+        name?: string;
+    }>;
+    provider: string;
+}): {
+    modelSelection?: ModelDirectiveSelection;
+    profileOverride?: string;
+    errorText?: string;
+};

package/dist/plugin-sdk/auto-reply/reply/directive-handling.parse.d.ts

@@ -0,0 +1,62 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { ExecAsk, ExecHost, ExecSecurity } from "../../infra/exec-approvals.js";
+import type { MsgContext } from "../templating.js";
+import type { ElevatedLevel, ReasoningLevel, ThinkLevel, VerboseLevel } from "./directives.js";
+import type { QueueDropPolicy, QueueMode } from "./queue.js";
+export type InlineDirectives = {
+    cleaned: string;
+    hasThinkDirective: boolean;
+    thinkLevel?: ThinkLevel;
+    rawThinkLevel?: string;
+    hasVerboseDirective: boolean;
+    verboseLevel?: VerboseLevel;
+    rawVerboseLevel?: string;
+    hasReasoningDirective: boolean;
+    reasoningLevel?: ReasoningLevel;
+    rawReasoningLevel?: string;
+    hasElevatedDirective: boolean;
+    elevatedLevel?: ElevatedLevel;
+    rawElevatedLevel?: string;
+    hasExecDirective: boolean;
+    execHost?: ExecHost;
+    execSecurity?: ExecSecurity;
+    execAsk?: ExecAsk;
+    execNode?: string;
+    rawExecHost?: string;
+    rawExecSecurity?: string;
+    rawExecAsk?: string;
+    rawExecNode?: string;
+    hasExecOptions: boolean;
+    invalidExecHost: boolean;
+    invalidExecSecurity: boolean;
+    invalidExecAsk: boolean;
+    invalidExecNode: boolean;
+    hasStatusDirective: boolean;
+    hasModelDirective: boolean;
+    rawModelDirective?: string;
+    rawModelProfile?: string;
+    hasQueueDirective: boolean;
+    queueMode?: QueueMode;
+    queueReset: boolean;
+    rawQueueMode?: string;
+    debounceMs?: number;
+    cap?: number;
+    dropPolicy?: QueueDropPolicy;
+    rawDebounce?: string;
+    rawCap?: string;
+    rawDrop?: string;
+    hasQueueOptions: boolean;
+};
+export declare function parseInlineDirectives(body: string, options?: {
+    modelAliases?: string[];
+    disableElevated?: boolean;
+    allowStatusDirective?: boolean;
+}): InlineDirectives;
+export declare function isDirectiveOnly(params: {
+    directives: InlineDirectives;
+    cleanedBody: string;
+    ctx: MsgContext;
+    cfg: SKYKOIConfig;
+    agentId?: string;
+    isGroup: boolean;
+}): boolean;

package/dist/plugin-sdk/auto-reply/reply/directive-handling.persist.d.ts

@@ -0,0 +1,37 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { InlineDirectives } from "./directive-handling.parse.js";
+import { type ModelAliasIndex } from "../../agents/model-selection.js";
+import { type SessionEntry } from "../../config/sessions.js";
+export declare function persistInlineDirectives(params: {
+    directives: InlineDirectives;
+    effectiveModelDirective?: string;
+    cfg: SKYKOIConfig;
+    agentDir?: string;
+    sessionEntry?: SessionEntry;
+    sessionStore?: Record<string, SessionEntry>;
+    sessionKey?: string;
+    storePath?: string;
+    elevatedEnabled: boolean;
+    elevatedAllowed: boolean;
+    defaultProvider: string;
+    defaultModel: string;
+    aliasIndex: ModelAliasIndex;
+    allowedModelKeys: Set<string>;
+    provider: string;
+    model: string;
+    initialModelLabel: string;
+    formatModelSwitchEvent: (label: string, alias?: string) => string;
+    agentCfg: NonNullable<SKYKOIConfig["agents"]>["defaults"] | undefined;
+}): Promise<{
+    provider: string;
+    model: string;
+    contextTokens: number;
+}>;
+export declare function resolveDefaultModel(params: {
+    cfg: SKYKOIConfig;
+    agentId?: string;
+}): {
+    defaultProvider: string;
+    defaultModel: string;
+    aliasIndex: ModelAliasIndex;
+};

package/dist/plugin-sdk/auto-reply/reply/directive-handling.queue-validation.d.ts

@@ -0,0 +1,10 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { SessionEntry } from "../../config/sessions.js";
+import type { ReplyPayload } from "../types.js";
+import type { InlineDirectives } from "./directive-handling.parse.js";
+export declare function maybeHandleQueueDirective(params: {
+    directives: InlineDirectives;
+    cfg: SKYKOIConfig;
+    channel: string;
+    sessionEntry?: SessionEntry;
+}): ReplyPayload | undefined;

package/dist/plugin-sdk/auto-reply/reply/directive-handling.shared.d.ts

@@ -0,0 +1,16 @@
+import type { ElevatedLevel, ReasoningLevel } from "./directives.js";
+export declare const SYSTEM_MARK = "\u2699\uFE0F";
+export declare const formatDirectiveAck: (text: string) => string;
+export declare const formatOptionsLine: (options: string) => string;
+export declare const withOptions: (line: string, options: string) => string;
+export declare const formatElevatedRuntimeHint: () => string;
+export declare const formatElevatedEvent: (level: ElevatedLevel) => "Elevated FULL — exec runs on host with auto-approval." | "Elevated ASK — exec runs on host; approvals may still apply." | "Elevated OFF — exec stays in sandbox.";
+export declare const formatReasoningEvent: (level: ReasoningLevel) => "Reasoning STREAM — emit live <think>." | "Reasoning ON — include <think>." | "Reasoning OFF — hide <think>.";
+export declare function formatElevatedUnavailableText(params: {
+    runtimeSandboxed: boolean;
+    failures?: Array<{
+        gate: string;
+        key: string;
+    }>;
+    sessionKey?: string;
+}): string;