skykoi 2026.3.21 → 2026.3.23

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

@@ -0,0 +1,38 @@
+import type { NoticeLevel, ReasoningLevel } from "../thinking.js";
+import { type ElevatedLevel, type ThinkLevel, type VerboseLevel } from "../thinking.js";
+export declare function extractThinkDirective(body?: string): {
+    cleaned: string;
+    thinkLevel?: ThinkLevel;
+    rawLevel?: string;
+    hasDirective: boolean;
+};
+export declare function extractVerboseDirective(body?: string): {
+    cleaned: string;
+    verboseLevel?: VerboseLevel;
+    rawLevel?: string;
+    hasDirective: boolean;
+};
+export declare function extractNoticeDirective(body?: string): {
+    cleaned: string;
+    noticeLevel?: NoticeLevel;
+    rawLevel?: string;
+    hasDirective: boolean;
+};
+export declare function extractElevatedDirective(body?: string): {
+    cleaned: string;
+    elevatedLevel?: ElevatedLevel;
+    rawLevel?: string;
+    hasDirective: boolean;
+};
+export declare function extractReasoningDirective(body?: string): {
+    cleaned: string;
+    reasoningLevel?: ReasoningLevel;
+    rawLevel?: string;
+    hasDirective: boolean;
+};
+export declare function extractStatusDirective(body?: string): {
+    cleaned: string;
+    hasDirective: boolean;
+};
+export type { ElevatedLevel, NoticeLevel, ReasoningLevel, ThinkLevel, VerboseLevel };
+export { extractExecDirective } from "./exec/directive.js";

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

@@ -0,0 +1,16 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { FinalizedMsgContext } from "../templating.js";
+import type { GetReplyOptions } from "../types.js";
+import type { ReplyDispatcher, ReplyDispatchKind } from "./reply-dispatcher.js";
+import { getReplyFromConfig } from "../reply.js";
+export type DispatchFromConfigResult = {
+    queuedFinal: boolean;
+    counts: Record<ReplyDispatchKind, number>;
+};
+export declare function dispatchReplyFromConfig(params: {
+    ctx: FinalizedMsgContext;
+    cfg: SKYKOIConfig;
+    dispatcher: ReplyDispatcher;
+    replyOptions?: Omit<GetReplyOptions, "onToolResult" | "onBlockReply">;
+    replyResolver?: typeof getReplyFromConfig;
+}): Promise<DispatchFromConfigResult>;

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

@@ -0,0 +1,20 @@
+import type { ExecAsk, ExecHost, ExecSecurity } from "../../../infra/exec-approvals.js";
+type ExecDirectiveParse = {
+    cleaned: string;
+    hasDirective: boolean;
+    execHost?: ExecHost;
+    execSecurity?: ExecSecurity;
+    execAsk?: ExecAsk;
+    execNode?: string;
+    rawExecHost?: string;
+    rawExecSecurity?: string;
+    rawExecAsk?: string;
+    rawExecNode?: string;
+    hasExecOptions: boolean;
+    invalidHost: boolean;
+    invalidSecurity: boolean;
+    invalidAsk: boolean;
+    invalidNode: boolean;
+};
+export declare function extractExecDirective(body?: string): ExecDirectiveParse;
+export {};

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

@@ -0,0 +1 @@
+export { extractExecDirective } from "./exec/directive.js";

package/dist/plugin-sdk/auto-reply/reply/followup-runner.d.ts

@@ -0,0 +1,16 @@
+import type { TypingMode } from "../../config/types.js";
+import type { GetReplyOptions } from "../types.js";
+import type { FollowupRun } from "./queue.js";
+import type { TypingController } from "./typing.js";
+import { type SessionEntry } from "../../config/sessions.js";
+export declare function createFollowupRunner(params: {
+    opts?: GetReplyOptions;
+    typing: TypingController;
+    typingMode: TypingMode;
+    sessionEntry?: SessionEntry;
+    sessionStore?: Record<string, SessionEntry>;
+    sessionKey?: string;
+    storePath?: string;
+    defaultModel: string;
+    agentCfgContextTokens?: number;
+}): (queued: FollowupRun) => Promise<void>;

package/dist/plugin-sdk/auto-reply/reply/get-reply-directives-apply.d.ts

@@ -0,0 +1,64 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { SessionEntry } from "../../config/sessions.js";
+import type { MsgContext } from "../templating.js";
+import type { ElevatedLevel } from "../thinking.js";
+import type { ReplyPayload } from "../types.js";
+import type { createModelSelectionState } from "./model-selection.js";
+import type { TypingController } from "./typing.js";
+import { buildStatusReply } from "./commands.js";
+import { applyInlineDirectivesFastLane, type InlineDirectives } from "./directive-handling.js";
+type AgentDefaults = NonNullable<SKYKOIConfig["agents"]>["defaults"];
+export type ApplyDirectiveResult = {
+    kind: "reply";
+    reply: ReplyPayload | ReplyPayload[] | undefined;
+} | {
+    kind: "continue";
+    directives: InlineDirectives;
+    provider: string;
+    model: string;
+    contextTokens: number;
+    directiveAck?: ReplyPayload;
+    perMessageQueueMode?: InlineDirectives["queueMode"];
+    perMessageQueueOptions?: {
+        debounceMs?: number;
+        cap?: number;
+        dropPolicy?: InlineDirectives["dropPolicy"];
+    };
+};
+export declare function applyInlineDirectiveOverrides(params: {
+    ctx: MsgContext;
+    cfg: SKYKOIConfig;
+    agentId: string;
+    agentDir: string;
+    agentCfg: AgentDefaults;
+    sessionEntry: SessionEntry;
+    sessionStore: Record<string, SessionEntry>;
+    sessionKey: string;
+    storePath?: string;
+    sessionScope: Parameters<typeof buildStatusReply>[0]["sessionScope"];
+    isGroup: boolean;
+    allowTextCommands: boolean;
+    command: Parameters<typeof buildStatusReply>[0]["command"];
+    directives: InlineDirectives;
+    messageProviderKey: string;
+    elevatedEnabled: boolean;
+    elevatedAllowed: boolean;
+    elevatedFailures: Array<{
+        gate: string;
+        key: string;
+    }>;
+    defaultProvider: string;
+    defaultModel: string;
+    aliasIndex: Parameters<typeof applyInlineDirectivesFastLane>[0]["aliasIndex"];
+    provider: string;
+    model: string;
+    modelState: Awaited<ReturnType<typeof createModelSelectionState>>;
+    initialModelLabel: string;
+    formatModelSwitchEvent: (label: string, alias?: string) => string;
+    resolvedElevatedLevel: ElevatedLevel;
+    defaultActivation: () => ReturnType<Parameters<typeof buildStatusReply>[0]["defaultGroupActivation"]>;
+    contextTokens: number;
+    effectiveModelDirective?: string;
+    typing: TypingController;
+}): Promise<ApplyDirectiveResult>;
+export {};

package/dist/plugin-sdk/auto-reply/reply/get-reply-directives-utils.d.ts

@@ -0,0 +1,2 @@
+import type { InlineDirectives } from "./directive-handling.js";
+export declare function clearInlineDirectives(cleaned: string): InlineDirectives;

package/dist/plugin-sdk/auto-reply/reply/get-reply-directives.d.ts

@@ -0,0 +1,91 @@
+import type { ExecToolDefaults } from "../../agents/bash-tools.js";
+import type { ModelAliasIndex } from "../../agents/model-selection.js";
+import type { SkillCommandSpec } from "../../agents/skills.js";
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { SessionEntry } from "../../config/sessions.js";
+import type { MsgContext, TemplateContext } from "../templating.js";
+import type { ElevatedLevel, ReasoningLevel, ThinkLevel, VerboseLevel } from "../thinking.js";
+import type { GetReplyOptions, ReplyPayload } from "../types.js";
+import type { TypingController } from "./typing.js";
+import { buildCommandContext } from "./commands.js";
+import { type InlineDirectives } from "./directive-handling.js";
+import { applyInlineDirectiveOverrides } from "./get-reply-directives-apply.js";
+import { defaultGroupActivation, resolveGroupRequireMention } from "./groups.js";
+import { createModelSelectionState } from "./model-selection.js";
+type AgentDefaults = NonNullable<SKYKOIConfig["agents"]>["defaults"];
+type ExecOverrides = Pick<ExecToolDefaults, "host" | "security" | "ask" | "node">;
+export type ReplyDirectiveContinuation = {
+    commandSource: string;
+    command: ReturnType<typeof buildCommandContext>;
+    allowTextCommands: boolean;
+    skillCommands?: SkillCommandSpec[];
+    directives: InlineDirectives;
+    cleanedBody: string;
+    messageProviderKey: string;
+    elevatedEnabled: boolean;
+    elevatedAllowed: boolean;
+    elevatedFailures: Array<{
+        gate: string;
+        key: string;
+    }>;
+    defaultActivation: ReturnType<typeof defaultGroupActivation>;
+    resolvedThinkLevel: ThinkLevel | undefined;
+    resolvedVerboseLevel: VerboseLevel | undefined;
+    resolvedReasoningLevel: ReasoningLevel;
+    resolvedElevatedLevel: ElevatedLevel;
+    execOverrides?: ExecOverrides;
+    blockStreamingEnabled: boolean;
+    blockReplyChunking?: {
+        minChars: number;
+        maxChars: number;
+        breakPreference: "paragraph" | "newline" | "sentence";
+        flushOnParagraph?: boolean;
+    };
+    resolvedBlockStreamingBreak: "text_end" | "message_end";
+    provider: string;
+    model: string;
+    modelState: Awaited<ReturnType<typeof createModelSelectionState>>;
+    contextTokens: number;
+    inlineStatusRequested: boolean;
+    directiveAck?: ReplyPayload;
+    perMessageQueueMode?: InlineDirectives["queueMode"];
+    perMessageQueueOptions?: {
+        debounceMs?: number;
+        cap?: number;
+        dropPolicy?: InlineDirectives["dropPolicy"];
+    };
+};
+export type ReplyDirectiveResult = {
+    kind: "reply";
+    reply: ReplyPayload | ReplyPayload[] | undefined;
+} | {
+    kind: "continue";
+    result: ReplyDirectiveContinuation;
+};
+export declare function resolveReplyDirectives(params: {
+    ctx: MsgContext;
+    cfg: SKYKOIConfig;
+    agentId: string;
+    agentDir: string;
+    workspaceDir: string;
+    agentCfg: AgentDefaults;
+    sessionCtx: TemplateContext;
+    sessionEntry: SessionEntry;
+    sessionStore: Record<string, SessionEntry>;
+    sessionKey: string;
+    storePath?: string;
+    sessionScope: Parameters<typeof applyInlineDirectiveOverrides>[0]["sessionScope"];
+    groupResolution: Parameters<typeof resolveGroupRequireMention>[0]["groupResolution"];
+    isGroup: boolean;
+    triggerBodyNormalized: string;
+    commandAuthorized: boolean;
+    defaultProvider: string;
+    defaultModel: string;
+    aliasIndex: ModelAliasIndex;
+    provider: string;
+    model: string;
+    typing: TypingController;
+    opts?: GetReplyOptions;
+    skillFilter?: string[];
+}): Promise<ReplyDirectiveResult>;
+export {};

package/dist/plugin-sdk/auto-reply/reply/get-reply-inline-actions.d.ts

@@ -0,0 +1,59 @@
+import type { SkillCommandSpec } from "../../agents/skills.js";
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { SessionEntry } from "../../config/sessions.js";
+import type { MsgContext, TemplateContext } from "../templating.js";
+import type { ElevatedLevel, ReasoningLevel, ThinkLevel, VerboseLevel } from "../thinking.js";
+import type { GetReplyOptions, ReplyPayload } from "../types.js";
+import type { InlineDirectives } from "./directive-handling.js";
+import type { createModelSelectionState } from "./model-selection.js";
+import type { TypingController } from "./typing.js";
+import { buildStatusReply, handleCommands } from "./commands.js";
+export type InlineActionResult = {
+    kind: "reply";
+    reply: ReplyPayload | ReplyPayload[] | undefined;
+} | {
+    kind: "continue";
+    directives: InlineDirectives;
+    abortedLastRun: boolean;
+};
+export declare function handleInlineActions(params: {
+    ctx: MsgContext;
+    sessionCtx: TemplateContext;
+    cfg: SKYKOIConfig;
+    agentId: string;
+    agentDir?: string;
+    sessionEntry?: SessionEntry;
+    previousSessionEntry?: SessionEntry;
+    sessionStore?: Record<string, SessionEntry>;
+    sessionKey: string;
+    storePath?: string;
+    sessionScope: Parameters<typeof buildStatusReply>[0]["sessionScope"];
+    workspaceDir: string;
+    isGroup: boolean;
+    opts?: GetReplyOptions;
+    typing: TypingController;
+    allowTextCommands: boolean;
+    inlineStatusRequested: boolean;
+    command: Parameters<typeof handleCommands>[0]["command"];
+    skillCommands?: SkillCommandSpec[];
+    directives: InlineDirectives;
+    cleanedBody: string;
+    elevatedEnabled: boolean;
+    elevatedAllowed: boolean;
+    elevatedFailures: Array<{
+        gate: string;
+        key: string;
+    }>;
+    defaultActivation: Parameters<typeof buildStatusReply>[0]["defaultGroupActivation"];
+    resolvedThinkLevel: ThinkLevel | undefined;
+    resolvedVerboseLevel: VerboseLevel | undefined;
+    resolvedReasoningLevel: ReasoningLevel;
+    resolvedElevatedLevel: ElevatedLevel;
+    resolveDefaultThinkingLevel: Awaited<ReturnType<typeof createModelSelectionState>>["resolveDefaultThinkingLevel"];
+    provider: string;
+    model: string;
+    contextTokens: number;
+    directiveAck?: ReplyPayload;
+    abortedLastRun: boolean;
+    skillFilter?: string[];
+}): Promise<InlineActionResult>;

package/dist/plugin-sdk/auto-reply/reply/get-reply-run.d.ts

@@ -0,0 +1,69 @@
+import type { ExecToolDefaults } from "../../agents/bash-tools.js";
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { MsgContext, TemplateContext } from "../templating.js";
+import type { GetReplyOptions, ReplyPayload } from "../types.js";
+import type { buildCommandContext } from "./commands.js";
+import type { InlineDirectives } from "./directive-handling.js";
+import type { createModelSelectionState } from "./model-selection.js";
+import type { TypingController } from "./typing.js";
+import { type SessionEntry } from "../../config/sessions.js";
+import { type ElevatedLevel, type ReasoningLevel, type ThinkLevel, type VerboseLevel } from "../thinking.js";
+import { buildGroupIntro } from "./groups.js";
+type AgentDefaults = NonNullable<SKYKOIConfig["agents"]>["defaults"];
+type ExecOverrides = Pick<ExecToolDefaults, "host" | "security" | "ask" | "node">;
+type RunPreparedReplyParams = {
+    ctx: MsgContext;
+    sessionCtx: TemplateContext;
+    cfg: SKYKOIConfig;
+    agentId: string;
+    agentDir: string;
+    agentCfg: AgentDefaults;
+    sessionCfg: SKYKOIConfig["session"];
+    commandAuthorized: boolean;
+    command: ReturnType<typeof buildCommandContext>;
+    commandSource: string;
+    allowTextCommands: boolean;
+    directives: InlineDirectives;
+    defaultActivation: Parameters<typeof buildGroupIntro>[0]["defaultActivation"];
+    resolvedThinkLevel: ThinkLevel | undefined;
+    resolvedVerboseLevel: VerboseLevel | undefined;
+    resolvedReasoningLevel: ReasoningLevel;
+    resolvedElevatedLevel: ElevatedLevel;
+    execOverrides?: ExecOverrides;
+    elevatedEnabled: boolean;
+    elevatedAllowed: boolean;
+    blockStreamingEnabled: boolean;
+    blockReplyChunking?: {
+        minChars: number;
+        maxChars: number;
+        breakPreference: "paragraph" | "newline" | "sentence";
+        flushOnParagraph?: boolean;
+    };
+    resolvedBlockStreamingBreak: "text_end" | "message_end";
+    modelState: Awaited<ReturnType<typeof createModelSelectionState>>;
+    provider: string;
+    model: string;
+    perMessageQueueMode?: InlineDirectives["queueMode"];
+    perMessageQueueOptions?: {
+        debounceMs?: number;
+        cap?: number;
+        dropPolicy?: InlineDirectives["dropPolicy"];
+    };
+    typing: TypingController;
+    opts?: GetReplyOptions;
+    defaultProvider: string;
+    defaultModel: string;
+    timeoutMs: number;
+    isNewSession: boolean;
+    resetTriggered: boolean;
+    systemSent: boolean;
+    sessionEntry?: SessionEntry;
+    sessionStore?: Record<string, SessionEntry>;
+    sessionKey: string;
+    sessionId?: string;
+    storePath?: string;
+    workspaceDir: string;
+    abortedLastRun: boolean;
+};
+export declare function runPreparedReply(params: RunPreparedReplyParams): Promise<ReplyPayload | ReplyPayload[] | undefined>;
+export {};

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

@@ -0,0 +1,4 @@
+import type { MsgContext } from "../templating.js";
+import type { GetReplyOptions, ReplyPayload } from "../types.js";
+import { type SKYKOIConfig } from "../../config/config.js";
+export declare function getReplyFromConfig(ctx: MsgContext, opts?: GetReplyOptions, configOverride?: SKYKOIConfig): Promise<ReplyPayload | ReplyPayload[] | undefined>;

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

@@ -0,0 +1,16 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { GroupKeyResolution, SessionEntry } from "../../config/sessions.js";
+import type { TemplateContext } from "../templating.js";
+export declare function resolveGroupRequireMention(params: {
+    cfg: SKYKOIConfig;
+    ctx: TemplateContext;
+    groupResolution?: GroupKeyResolution;
+}): boolean;
+export declare function defaultGroupActivation(requireMention: boolean): "always" | "mention";
+export declare function buildGroupIntro(params: {
+    cfg: SKYKOIConfig;
+    sessionCtx: TemplateContext;
+    sessionEntry?: SessionEntry;
+    defaultActivation: "always" | "mention";
+    silentToken: string;
+}): string;

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

@@ -0,0 +1,72 @@
+export declare const HISTORY_CONTEXT_MARKER = "[Chat messages since your last reply - for context]";
+export declare const DEFAULT_GROUP_HISTORY_LIMIT = 50;
+/** Maximum number of group history keys to retain (LRU eviction when exceeded). */
+export declare const MAX_HISTORY_KEYS = 1000;
+/**
+ * Evict oldest keys from a history map when it exceeds MAX_HISTORY_KEYS.
+ * Uses Map's insertion order for LRU-like behavior.
+ */
+export declare function evictOldHistoryKeys<T>(historyMap: Map<string, T[]>, maxKeys?: number): void;
+export type HistoryEntry = {
+    sender: string;
+    body: string;
+    timestamp?: number;
+    messageId?: string;
+};
+export declare function buildHistoryContext(params: {
+    historyText: string;
+    currentMessage: string;
+    lineBreak?: string;
+}): string;
+export declare function appendHistoryEntry<T extends HistoryEntry>(params: {
+    historyMap: Map<string, T[]>;
+    historyKey: string;
+    entry: T;
+    limit: number;
+}): T[];
+export declare function recordPendingHistoryEntry<T extends HistoryEntry>(params: {
+    historyMap: Map<string, T[]>;
+    historyKey: string;
+    entry: T;
+    limit: number;
+}): T[];
+export declare function recordPendingHistoryEntryIfEnabled<T extends HistoryEntry>(params: {
+    historyMap: Map<string, T[]>;
+    historyKey: string;
+    entry?: T | null;
+    limit: number;
+}): T[];
+export declare function buildPendingHistoryContextFromMap(params: {
+    historyMap: Map<string, HistoryEntry[]>;
+    historyKey: string;
+    limit: number;
+    currentMessage: string;
+    formatEntry: (entry: HistoryEntry) => string;
+    lineBreak?: string;
+}): string;
+export declare function buildHistoryContextFromMap(params: {
+    historyMap: Map<string, HistoryEntry[]>;
+    historyKey: string;
+    limit: number;
+    entry?: HistoryEntry;
+    currentMessage: string;
+    formatEntry: (entry: HistoryEntry) => string;
+    lineBreak?: string;
+    excludeLast?: boolean;
+}): string;
+export declare function clearHistoryEntries(params: {
+    historyMap: Map<string, HistoryEntry[]>;
+    historyKey: string;
+}): void;
+export declare function clearHistoryEntriesIfEnabled(params: {
+    historyMap: Map<string, HistoryEntry[]>;
+    historyKey: string;
+    limit: number;
+}): void;
+export declare function buildHistoryContextFromEntries(params: {
+    entries: HistoryEntry[];
+    currentMessage: string;
+    formatEntry: (entry: HistoryEntry) => string;
+    lineBreak?: string;
+    excludeLast?: boolean;
+}): string;

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

@@ -0,0 +1,8 @@
+import type { FinalizedMsgContext } from "../templating.js";
+export type FinalizeInboundContextOptions = {
+    forceBodyForAgent?: boolean;
+    forceBodyForCommands?: boolean;
+    forceChatType?: boolean;
+    forceConversationLabel?: boolean;
+};
+export declare function finalizeInboundContext<T extends Record<string, unknown>>(ctx: T, opts?: FinalizeInboundContextOptions): T & FinalizedMsgContext;

package/dist/plugin-sdk/auto-reply/reply/inbound-dedupe.d.ts

@@ -0,0 +1,8 @@
+import type { MsgContext } from "../templating.js";
+import { type DedupeCache } from "../../infra/dedupe.js";
+export declare function buildInboundDedupeKey(ctx: MsgContext): string | null;
+export declare function shouldSkipDuplicateInbound(ctx: MsgContext, opts?: {
+    cache?: DedupeCache;
+    now?: number;
+}): boolean;
+export declare function resetInboundDedupe(): void;

package/dist/plugin-sdk/auto-reply/reply/inbound-sender-meta.d.ts

@@ -0,0 +1,5 @@
+import type { MsgContext } from "../templating.js";
+export declare function formatInboundBodyWithSenderMeta(params: {
+    body: string;
+    ctx: MsgContext;
+}): string;

package/dist/plugin-sdk/auto-reply/reply/inbound-text.d.ts

@@ -0,0 +1 @@
+export declare function normalizeInboundTextNewlines(input: string): string;

package/dist/plugin-sdk/auto-reply/reply/line-directives.d.ts

@@ -0,0 +1,22 @@
+import type { ReplyPayload } from "../types.js";
+/**
+ * Parse LINE-specific directives from text and extract them into ReplyPayload fields.
+ *
+ * Supported directives:
+ * - [[quick_replies: option1, option2, option3]]
+ * - [[location: title | address | latitude | longitude]]
+ * - [[confirm: question | yes_label | no_label]]
+ * - [[buttons: title | text | btn1:data1, btn2:data2]]
+ * - [[media_player: title | artist | source | imageUrl | playing/paused]]
+ * - [[event: title | date | time | location | description]]
+ * - [[agenda: title | event1_title:event1_time, event2_title:event2_time, ...]]
+ * - [[device: name | type | status | ctrl1:data1, ctrl2:data2]]
+ * - [[appletv_remote: name | status]]
+ *
+ * Returns the modified payload with directives removed from text and fields populated.
+ */
+export declare function parseLineDirectives(payload: ReplyPayload): ReplyPayload;
+/**
+ * Check if text contains any LINE directives
+ */
+export declare function hasLineDirectives(text: string): boolean;

package/dist/plugin-sdk/auto-reply/reply/memory-flush.d.ts

@@ -0,0 +1,23 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { SessionEntry } from "../../config/sessions.js";
+export declare const DEFAULT_MEMORY_FLUSH_SOFT_TOKENS = 4000;
+export declare const DEFAULT_MEMORY_FLUSH_PROMPT: string;
+export declare const DEFAULT_MEMORY_FLUSH_SYSTEM_PROMPT: string;
+export type MemoryFlushSettings = {
+    enabled: boolean;
+    softThresholdTokens: number;
+    prompt: string;
+    systemPrompt: string;
+    reserveTokensFloor: number;
+};
+export declare function resolveMemoryFlushSettings(cfg?: SKYKOIConfig): MemoryFlushSettings | null;
+export declare function resolveMemoryFlushContextWindowTokens(params: {
+    modelId?: string;
+    agentCfgContextTokens?: number;
+}): number;
+export declare function shouldRunMemoryFlush(params: {
+    entry?: Pick<SessionEntry, "totalTokens" | "compactionCount" | "memoryFlushCompactionCount">;
+    contextWindowTokens: number;
+    reserveTokensFloor: number;
+    softThresholdTokens: number;
+}): boolean;

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

@@ -0,0 +1,18 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { MsgContext } from "../templating.js";
+export declare const CURRENT_MESSAGE_MARKER = "[Current message - respond to this]";
+export declare function buildMentionRegexes(cfg: SKYKOIConfig | undefined, agentId?: string): RegExp[];
+export declare function normalizeMentionText(text: string): string;
+export declare function matchesMentionPatterns(text: string, mentionRegexes: RegExp[]): boolean;
+export type ExplicitMentionSignal = {
+    hasAnyMention: boolean;
+    isExplicitlyMentioned: boolean;
+    canResolveExplicit: boolean;
+};
+export declare function matchesMentionWithExplicit(params: {
+    text: string;
+    mentionRegexes: RegExp[];
+    explicit?: ExplicitMentionSignal;
+}): boolean;
+export declare function stripStructuralPrefixes(text: string): string;
+export declare function stripMentions(text: string, ctx: MsgContext, cfg: SKYKOIConfig | undefined, agentId?: string): string;

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

@@ -0,0 +1,61 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { ThinkLevel } from "./directives.js";
+import { loadModelCatalog } from "../../agents/model-catalog.js";
+import { type ModelAliasIndex } from "../../agents/model-selection.js";
+import { type SessionEntry } from "../../config/sessions.js";
+export type ModelDirectiveSelection = {
+    provider: string;
+    model: string;
+    isDefault: boolean;
+    alias?: string;
+};
+type ModelCatalog = Awaited<ReturnType<typeof loadModelCatalog>>;
+type ModelSelectionState = {
+    provider: string;
+    model: string;
+    allowedModelKeys: Set<string>;
+    allowedModelCatalog: ModelCatalog;
+    resetModelOverride: boolean;
+    resolveDefaultThinkingLevel: () => Promise<ThinkLevel>;
+    needsModelCatalog: boolean;
+};
+export type StoredModelOverride = {
+    provider?: string;
+    model: string;
+    source: "session" | "parent";
+};
+export declare function resolveStoredModelOverride(params: {
+    sessionEntry?: SessionEntry;
+    sessionStore?: Record<string, SessionEntry>;
+    sessionKey?: string;
+    parentSessionKey?: string;
+}): StoredModelOverride | null;
+export declare function createModelSelectionState(params: {
+    cfg: SKYKOIConfig;
+    agentCfg: NonNullable<NonNullable<SKYKOIConfig["agents"]>["defaults"]> | undefined;
+    sessionEntry?: SessionEntry;
+    sessionStore?: Record<string, SessionEntry>;
+    sessionKey?: string;
+    parentSessionKey?: string;
+    storePath?: string;
+    defaultProvider: string;
+    defaultModel: string;
+    provider: string;
+    model: string;
+    hasModelDirective: boolean;
+}): Promise<ModelSelectionState>;
+export declare function resolveModelDirectiveSelection(params: {
+    raw: string;
+    defaultProvider: string;
+    defaultModel: string;
+    aliasIndex: ModelAliasIndex;
+    allowedModelKeys: Set<string>;
+}): {
+    selection?: ModelDirectiveSelection;
+    error?: string;
+};
+export declare function resolveContextTokens(params: {
+    agentCfg: NonNullable<NonNullable<SKYKOIConfig["agents"]>["defaults"]> | undefined;
+    model: string;
+}): number;
+export {};

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

@@ -0,0 +1,13 @@
+import type { ReplyPayload } from "../types.js";
+import { type ResponsePrefixContext } from "./response-prefix-template.js";
+export type NormalizeReplySkipReason = "empty" | "silent" | "heartbeat";
+export type NormalizeReplyOptions = {
+    responsePrefix?: string;
+    /** Context for template variable interpolation in responsePrefix */
+    responsePrefixContext?: ResponsePrefixContext;
+    onHeartbeatStrip?: () => void;
+    stripHeartbeat?: boolean;
+    silentToken?: string;
+    onSkip?: (reason: NormalizeReplySkipReason) => void;
+};
+export declare function normalizeReplyPayload(payload: ReplyPayload, opts?: NormalizeReplyOptions): ReplyPayload | null;