openclaw-cortex 3.4.0 → 3.5.0

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

@@ -0,0 +1,9 @@
+import type { OpenClawConfig } from "../../config/config.js";
+import type { ReplyToMode } from "../../config/types.js";
+import type { OriginatingChannelType } from "../templating.js";
+import type { ReplyPayload } from "../types.js";
+export declare function resolveReplyToMode(cfg: OpenClawConfig, channel?: OriginatingChannelType, accountId?: string | null, chatType?: string | null): ReplyToMode;
+export declare function createReplyToModeFilter(mode: ReplyToMode, opts?: {
+    allowExplicitReplyTagsWhenOff?: boolean;
+}): (payload: ReplyPayload) => ReplyPayload;
+export declare function createReplyToModeFilterForChannel(mode: ReplyToMode, channel?: OriginatingChannelType): (payload: ReplyPayload) => ReplyPayload;

package/dist/plugin-sdk/auto-reply/reply/response-prefix-template.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Template interpolation for response prefix.
+ *
+ * Supports variables like `{model}`, `{provider}`, `{thinkingLevel}`, etc.
+ * Variables are case-insensitive and unresolved ones remain as literal text.
+ */
+export type ResponsePrefixContext = {
+    /** Short model name (e.g., "gpt-5.2", "claude-opus-4-6") */
+    model?: string;
+    /** Full model ID including provider (e.g., "openai-codex/gpt-5.2") */
+    modelFull?: string;
+    /** Provider name (e.g., "openai-codex", "anthropic") */
+    provider?: string;
+    /** Current thinking level (e.g., "high", "low", "off") */
+    thinkingLevel?: string;
+    /** Agent identity name */
+    identityName?: string;
+};
+/**
+ * Interpolate template variables in a response prefix string.
+ *
+ * @param template - The template string with `{variable}` placeholders
+ * @param context - Context object with values for interpolation
+ * @returns The interpolated string, or undefined if template is undefined
+ *
+ * @example
+ * resolveResponsePrefixTemplate("[{model} | think:{thinkingLevel}]", {
+ *   model: "gpt-5.2",
+ *   thinkingLevel: "high"
+ * })
+ * // Returns: "[gpt-5.2 | think:high]"
+ */
+export declare function resolveResponsePrefixTemplate(template: string | undefined, context: ResponsePrefixContext): string | undefined;
+/**
+ * Extract short model name from a full model string.
+ *
+ * Strips:
+ * - Provider prefix (e.g., "openai/" from "openai/gpt-5.2")
+ * - Date suffixes (e.g., "-20260205" from "claude-opus-4-6-20260205")
+ * - Common version suffixes (e.g., "-latest")
+ *
+ * @example
+ * extractShortModelName("openai-codex/gpt-5.2") // "gpt-5.2"
+ * extractShortModelName("claude-opus-4-6-20260205") // "claude-opus-4-6"
+ * extractShortModelName("gpt-5.2-latest") // "gpt-5.2"
+ */
+export declare function extractShortModelName(fullModel: string): string;
+/**
+ * Check if a template string contains any template variables.
+ */
+export declare function hasTemplateVariables(template: string | undefined): boolean;

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

@@ -0,0 +1,56 @@
+/**
+ * Provider-agnostic reply router.
+ *
+ * Routes replies to the originating channel based on OriginatingChannel/OriginatingTo
+ * instead of using the session's lastChannel. This ensures replies go back to the
+ * provider where the message originated, even when the main session is shared
+ * across multiple providers.
+ */
+import type { OpenClawConfig } from "../../config/config.js";
+import { INTERNAL_MESSAGE_CHANNEL } from "../../utils/message-channel.js";
+import type { OriginatingChannelType } from "../templating.js";
+import type { ReplyPayload } from "../types.js";
+export type RouteReplyParams = {
+    /** The reply payload to send. */
+    payload: ReplyPayload;
+    /** The originating channel type (telegram, slack, etc). */
+    channel: OriginatingChannelType;
+    /** The destination chat/channel/user ID. */
+    to: string;
+    /** Session key for deriving agent identity defaults (multi-agent). */
+    sessionKey?: string;
+    /** Provider account id (multi-account). */
+    accountId?: string;
+    /** Thread id for replies (Telegram topic id or Matrix thread event id). */
+    threadId?: string | number;
+    /** Config for provider-specific settings. */
+    cfg: OpenClawConfig;
+    /** Optional abort signal for cooperative cancellation. */
+    abortSignal?: AbortSignal;
+    /** Mirror reply into session transcript (default: true when sessionKey is set). */
+    mirror?: boolean;
+};
+export type RouteReplyResult = {
+    /** Whether the reply was sent successfully. */
+    ok: boolean;
+    /** Optional message ID from the provider. */
+    messageId?: string;
+    /** Error message if the send failed. */
+    error?: string;
+};
+/**
+ * Routes a reply payload to the specified channel.
+ *
+ * This function provides a unified interface for sending messages to any
+ * supported provider. It's used by the followup queue to route replies
+ * back to the originating channel when OriginatingChannel/OriginatingTo
+ * are set.
+ */
+export declare function routeReply(params: RouteReplyParams): Promise<RouteReplyResult>;
+/**
+ * Checks if a channel type is routable via routeReply.
+ *
+ * Some channels (webchat) require special handling and cannot be routed through
+ * this generic interface.
+ */
+export declare function isRoutableChannel(channel: OriginatingChannelType | undefined): channel is Exclude<OriginatingChannelType, typeof INTERNAL_MESSAGE_CHANNEL>;

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

@@ -0,0 +1,24 @@
+import { type ModelAliasIndex } from "../../agents/model-selection.js";
+import type { OpenClawConfig } from "../../config/config.js";
+import type { SessionEntry } from "../../config/sessions.js";
+import type { MsgContext, TemplateContext } from "../templating.js";
+import { type ModelDirectiveSelection } from "./model-selection.js";
+type ResetModelResult = {
+    selection?: ModelDirectiveSelection;
+    cleanedBody?: string;
+};
+export declare function applyResetModelOverride(params: {
+    cfg: OpenClawConfig;
+    resetTriggered: boolean;
+    bodyStripped?: string;
+    sessionCtx: TemplateContext;
+    ctx: MsgContext;
+    sessionEntry?: SessionEntry;
+    sessionStore?: Record<string, SessionEntry>;
+    sessionKey?: string;
+    storePath?: string;
+    defaultProvider: string;
+    defaultModel: string;
+    aliasIndex: ModelAliasIndex;
+}): Promise<ResetModelResult>;
+export {};

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

@@ -0,0 +1 @@
+export declare const BARE_SESSION_RESET_PROMPT = "A new session was started via /new or /reset. Execute your Session Startup sequence now - read the required files before responding to the user. Then greet the user in your configured persona, if one is provided. Be yourself - use your defined voice, mannerisms, and mood. Keep it to 1-3 sentences and ask what they want to do. If the runtime model differs from default_model in the system prompt, mention the default model. Do not mention internal steps, files, tools, or reasoning.";

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

@@ -0,0 +1,11 @@
+import { type NormalizedUsage } from "../../agents/usage.js";
+import { incrementCompactionCount } from "./session-updates.js";
+import { persistSessionUsageUpdate } from "./session-usage.js";
+type PersistRunSessionUsageParams = Parameters<typeof persistSessionUsageUpdate>[0];
+type IncrementRunCompactionCountParams = Omit<Parameters<typeof incrementCompactionCount>[0], "tokensAfter"> & {
+    lastCallUsage?: NormalizedUsage;
+    contextTokensUsed?: number;
+};
+export declare function persistRunSessionUsage(params: PersistRunSessionUsageParams): Promise<void>;
+export declare function incrementRunCompactionCount(params: IncrementRunCompactionCountParams): Promise<number | undefined>;
+export {};

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

@@ -0,0 +1,34 @@
+import type { OpenClawConfig } from "../../config/config.js";
+import { type SessionEntry } from "../../config/sessions.js";
+export declare function prependSystemEvents(params: {
+    cfg: OpenClawConfig;
+    sessionKey: string;
+    isMainSession: boolean;
+    isNewSession: boolean;
+    prefixedBodyBase: string;
+}): Promise<string>;
+export declare function ensureSkillSnapshot(params: {
+    sessionEntry?: SessionEntry;
+    sessionStore?: Record<string, SessionEntry>;
+    sessionKey?: string;
+    storePath?: string;
+    sessionId?: string;
+    isFirstTurnInSession: boolean;
+    workspaceDir: string;
+    cfg: OpenClawConfig;
+    /** If provided, only load skills with these names (for per-channel skill filtering) */
+    skillFilter?: string[];
+}): Promise<{
+    sessionEntry?: SessionEntry;
+    skillsSnapshot?: SessionEntry["skillsSnapshot"];
+    systemSent: boolean;
+}>;
+export declare function incrementCompactionCount(params: {
+    sessionEntry?: SessionEntry;
+    sessionStore?: Record<string, SessionEntry>;
+    sessionKey?: string;
+    storePath?: string;
+    now?: number;
+    /** Token count after compaction - if provided, updates session token counts */
+    tokensAfter?: number;
+}): Promise<number | undefined>;

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

@@ -0,0 +1,21 @@
+import { type NormalizedUsage } from "../../agents/usage.js";
+import { type SessionSystemPromptReport } from "../../config/sessions.js";
+export declare function persistSessionUsageUpdate(params: {
+    storePath?: string;
+    sessionKey?: string;
+    usage?: NormalizedUsage;
+    /**
+     * Usage from the last individual API call (not accumulated). When provided,
+     * this is used for `totalTokens` instead of the accumulated `usage` so that
+     * context-window utilization reflects the actual current context size rather
+     * than the sum of input tokens across all API calls in the run.
+     */
+    lastCallUsage?: NormalizedUsage;
+    modelUsed?: string;
+    providerUsed?: string;
+    contextTokensUsed?: number;
+    promptTokens?: number;
+    systemPromptReport?: SessionSystemPromptReport;
+    cliSessionId?: string;
+    logLabel?: string;
+}): Promise<void>;

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

@@ -0,0 +1,26 @@
+import type { OpenClawConfig } from "../../config/config.js";
+import { type GroupKeyResolution, type SessionEntry, type SessionScope } from "../../config/sessions.js";
+import type { MsgContext, TemplateContext } from "../templating.js";
+export type SessionInitResult = {
+    sessionCtx: TemplateContext;
+    sessionEntry: SessionEntry;
+    previousSessionEntry?: SessionEntry;
+    sessionStore: Record<string, SessionEntry>;
+    sessionKey: string;
+    sessionId: string;
+    isNewSession: boolean;
+    resetTriggered: boolean;
+    systemSent: boolean;
+    abortedLastRun: boolean;
+    storePath: string;
+    sessionScope: SessionScope;
+    groupResolution?: GroupKeyResolution;
+    isGroup: boolean;
+    bodyStripped?: string;
+    triggerBodyNormalized: string;
+};
+export declare function initSessionState(params: {
+    ctx: MsgContext;
+    cfg: OpenClawConfig;
+    commandAuthorized: boolean;
+}): Promise<SessionInitResult>;

package/dist/plugin-sdk/auto-reply/reply/stage-sandbox-media.d.ts

@@ -0,0 +1,9 @@
+import type { OpenClawConfig } from "../../config/config.js";
+import type { MsgContext, TemplateContext } from "../templating.js";
+export declare function stageSandboxMedia(params: {
+    ctx: MsgContext;
+    sessionCtx: TemplateContext;
+    cfg: OpenClawConfig;
+    sessionKey?: string;
+    workspaceDir: string;
+}): Promise<void>;

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

@@ -0,0 +1,10 @@
+import type { ReplyDirectiveParseResult } from "./reply-directives.js";
+type ConsumeOptions = {
+    final?: boolean;
+    silentToken?: string;
+};
+export declare function createStreamingDirectiveAccumulator(): {
+    consume: (raw: string, options?: ConsumeOptions) => ReplyDirectiveParseResult | null;
+    reset: () => void;
+};
+export {};

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

@@ -0,0 +1,26 @@
+/**
+ * Strips OpenClaw-injected inbound metadata blocks from a user-role message
+ * text before it is displayed in any UI surface (TUI, webchat, macOS app).
+ *
+ * Background: `buildInboundUserContextPrefix` in `inbound-meta.ts` prepends
+ * structured metadata blocks (Conversation info, Sender info, reply context,
+ * etc.) directly to the stored user message content so the LLM can access
+ * them. These blocks are AI-facing only and must never surface in user-visible
+ * chat history.
+ */
+/**
+ * Remove all injected inbound metadata prefix blocks from `text`.
+ *
+ * Each block has the shape:
+ *
+ * ```
+ * <sentinel-line>
+ * ```json
+ * { … }
+ * ```
+ * ```
+ *
+ * Returns the original string reference unchanged when no metadata is present
+ * (fast path — zero allocation).
+ */
+export declare function stripInboundMetadata(text: string): string;

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

@@ -0,0 +1,26 @@
+import type { SubagentRunRecord } from "../../agents/subagent-registry.js";
+export declare function resolveSubagentLabel(entry: SubagentRunRecord, fallback?: string): string;
+export declare function formatRunLabel(entry: SubagentRunRecord, options?: {
+    maxLength?: number;
+}): string;
+export declare function formatRunStatus(entry: SubagentRunRecord): "timeout" | "error" | "unknown" | "done" | "running";
+export declare function sortSubagentRuns(runs: SubagentRunRecord[]): SubagentRunRecord[];
+export type SubagentTargetResolution = {
+    entry?: SubagentRunRecord;
+    error?: string;
+};
+export declare function resolveSubagentTargetFromRuns(params: {
+    runs: SubagentRunRecord[];
+    token: string | undefined;
+    recentWindowMinutes: number;
+    label: (entry: SubagentRunRecord) => string;
+    errors: {
+        missingTarget: string;
+        invalidIndex: (value: string) => string;
+        unknownSession: (value: string) => string;
+        ambiguousLabel: (value: string) => string;
+        ambiguousLabelPrefix: (value: string) => string;
+        ambiguousRunIdPrefix: (value: string) => string;
+        unknownTarget: (value: string) => string;
+    };
+}): SubagentTargetResolution;

package/dist/plugin-sdk/auto-reply/reply/typing-mode.d.ts

@@ -0,0 +1,27 @@
+import type { TypingMode } from "../../config/types.js";
+import type { TypingController } from "./typing.js";
+export type TypingModeContext = {
+    configured?: TypingMode;
+    isGroupChat: boolean;
+    wasMentioned: boolean;
+    isHeartbeat: boolean;
+};
+export declare const DEFAULT_GROUP_TYPING_MODE: TypingMode;
+export declare function resolveTypingMode({ configured, isGroupChat, wasMentioned, isHeartbeat, }: TypingModeContext): TypingMode;
+export type TypingSignaler = {
+    mode: TypingMode;
+    shouldStartImmediately: boolean;
+    shouldStartOnMessageStart: boolean;
+    shouldStartOnText: boolean;
+    shouldStartOnReasoning: boolean;
+    signalRunStart: () => Promise<void>;
+    signalMessageStart: () => Promise<void>;
+    signalTextDelta: (text?: string) => Promise<void>;
+    signalReasoningDelta: () => Promise<void>;
+    signalToolStart: () => Promise<void>;
+};
+export declare function createTypingSignaler(params: {
+    typing: TypingController;
+    mode: TypingMode;
+    isHeartbeat: boolean;
+}): TypingSignaler;

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

@@ -0,0 +1,18 @@
+export type TypingController = {
+    onReplyStart: () => Promise<void>;
+    startTypingLoop: () => Promise<void>;
+    startTypingOnText: (text?: string) => Promise<void>;
+    refreshTypingTtl: () => void;
+    isActive: () => boolean;
+    markRunComplete: () => void;
+    markDispatchIdle: () => void;
+    cleanup: () => void;
+};
+export declare function createTypingController(params: {
+    onReplyStart?: () => Promise<void> | void;
+    onCleanup?: () => void;
+    typingIntervalSeconds?: number;
+    typingTtlMs?: number;
+    silentToken?: string;
+    log?: (message: string) => void;
+}): TypingController;

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

@@ -0,0 +1 @@
+export declare function appendUntrustedContext(base: string, untrusted?: string[]): string;

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

@@ -0,0 +1,6 @@
+export { extractElevatedDirective, extractReasoningDirective, extractThinkDirective, extractVerboseDirective, } from "./reply/directives.js";
+export { getReplyFromConfig } from "./reply/get-reply.js";
+export { extractExecDirective } from "./reply/exec.js";
+export { extractQueueDirective } from "./reply/queue.js";
+export { extractReplyToTag } from "./reply/reply-tags.js";
+export type { GetReplyOptions, ReplyPayload } from "./types.js";

package/dist/plugin-sdk/auto-reply/send-policy.d.ts

@@ -0,0 +1,6 @@
+export type SendPolicyOverride = "allow" | "deny";
+export declare function normalizeSendPolicyOverride(raw?: string | null): SendPolicyOverride | undefined;
+export declare function parseSendPolicyCommand(raw?: string): {
+    hasCommand: boolean;
+    mode?: SendPolicyOverride | "inherit";
+};

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

@@ -0,0 +1,19 @@
+import { type SkillCommandSpec } from "../agents/skills.js";
+import type { OpenClawConfig } from "../config/config.js";
+export declare function listReservedChatSlashCommandNames(extraNames?: string[]): Set<string>;
+export declare function listSkillCommandsForWorkspace(params: {
+    workspaceDir: string;
+    cfg: OpenClawConfig;
+    skillFilter?: string[];
+}): SkillCommandSpec[];
+export declare function listSkillCommandsForAgents(params: {
+    cfg: OpenClawConfig;
+    agentIds?: string[];
+}): SkillCommandSpec[];
+export declare function resolveSkillCommandInvocation(params: {
+    commandBodyNormalized: string;
+    skillCommands: SkillCommandSpec[];
+}): {
+    command: SkillCommandSpec;
+    args?: string;
+} | null;

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

@@ -0,0 +1,60 @@
+import type { SkillCommandSpec } from "../agents/skills.js";
+import type { OpenClawConfig } from "../config/config.js";
+import { type SessionEntry, type SessionScope } from "../config/sessions.js";
+import type { MediaUnderstandingDecision } from "../media-understanding/types.js";
+import { formatTokenCount as formatTokenCountShared } from "../utils/usage-format.js";
+import type { ElevatedLevel, ReasoningLevel, ThinkLevel, VerboseLevel } from "./thinking.js";
+type AgentDefaults = NonNullable<NonNullable<OpenClawConfig["agents"]>["defaults"]>;
+type AgentConfig = Partial<AgentDefaults> & {
+    model?: AgentDefaults["model"] | string;
+};
+export declare const formatTokenCount: typeof formatTokenCountShared;
+type QueueStatus = {
+    mode?: string;
+    depth?: number;
+    debounceMs?: number;
+    cap?: number;
+    dropPolicy?: string;
+    showDetails?: boolean;
+};
+type StatusArgs = {
+    config?: OpenClawConfig;
+    agent: AgentConfig;
+    agentId?: string;
+    sessionEntry?: SessionEntry;
+    sessionKey?: string;
+    parentSessionKey?: string;
+    sessionScope?: SessionScope;
+    sessionStorePath?: string;
+    groupActivation?: "mention" | "always";
+    resolvedThink?: ThinkLevel;
+    resolvedVerbose?: VerboseLevel;
+    resolvedReasoning?: ReasoningLevel;
+    resolvedElevated?: ElevatedLevel;
+    modelAuth?: string;
+    activeModelAuth?: string;
+    usageLine?: string;
+    timeLine?: string;
+    queue?: QueueStatus;
+    mediaDecisions?: ReadonlyArray<MediaUnderstandingDecision>;
+    subagentsLine?: string;
+    includeTranscriptUsage?: boolean;
+    now?: number;
+};
+export declare const formatContextUsageShort: (total: number | null | undefined, contextTokens: number | null | undefined) => string;
+export declare function buildStatusMessage(args: StatusArgs): string;
+export declare function buildHelpMessage(cfg?: OpenClawConfig): string;
+export type CommandsMessageOptions = {
+    page?: number;
+    surface?: string;
+};
+export type CommandsMessageResult = {
+    text: string;
+    totalPages: number;
+    currentPage: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+};
+export declare function buildCommandsMessage(cfg?: OpenClawConfig, skillCommands?: SkillCommandSpec[], options?: CommandsMessageOptions): string;
+export declare function buildCommandsMessagePaginated(cfg?: OpenClawConfig, skillCommands?: SkillCommandSpec[], options?: CommandsMessageOptions): CommandsMessageResult;
+export {};

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

@@ -0,0 +1,152 @@
+import type { ChannelId } from "../channels/plugins/types.js";
+import type { MediaUnderstandingDecision, MediaUnderstandingOutput } from "../media-understanding/types.js";
+import type { StickerMetadata } from "../telegram/bot/types.js";
+import type { InternalMessageChannel } from "../utils/message-channel.js";
+import type { CommandArgs } from "./commands-registry.types.js";
+/** Valid message channels for routing. */
+export type OriginatingChannelType = ChannelId | InternalMessageChannel;
+export type MsgContext = {
+    Body?: string;
+    /**
+     * Agent prompt body (may include envelope/history/context). Prefer this for prompt shaping.
+     * Should use real newlines (`\n`), not escaped `\\n`.
+     */
+    BodyForAgent?: string;
+    /**
+     * Recent chat history for context (untrusted user content). Prefer passing this
+     * as structured context blocks in the user prompt rather than rendering plaintext envelopes.
+     */
+    InboundHistory?: Array<{
+        sender: string;
+        body: string;
+        timestamp?: number;
+    }>;
+    /**
+     * Raw message body without structural context (history, sender labels).
+     * Legacy alias for CommandBody. Falls back to Body if not set.
+     */
+    RawBody?: string;
+    /**
+     * Prefer for command detection; RawBody is treated as legacy alias.
+     */
+    CommandBody?: string;
+    /**
+     * Command parsing body. Prefer this over CommandBody/RawBody when set.
+     * Should be the "clean" text (no history/sender context).
+     */
+    BodyForCommands?: string;
+    CommandArgs?: CommandArgs;
+    From?: string;
+    To?: string;
+    SessionKey?: string;
+    /** Provider account id (multi-account). */
+    AccountId?: string;
+    ParentSessionKey?: string;
+    MessageSid?: string;
+    /** Provider-specific full message id when MessageSid is a shortened alias. */
+    MessageSidFull?: string;
+    MessageSids?: string[];
+    MessageSidFirst?: string;
+    MessageSidLast?: string;
+    ReplyToId?: string;
+    /** Provider-specific full reply-to id when ReplyToId is a shortened alias. */
+    ReplyToIdFull?: string;
+    ReplyToBody?: string;
+    ReplyToSender?: string;
+    ReplyToIsQuote?: boolean;
+    ForwardedFrom?: string;
+    ForwardedFromType?: string;
+    ForwardedFromId?: string;
+    ForwardedFromUsername?: string;
+    ForwardedFromTitle?: string;
+    ForwardedFromSignature?: string;
+    ForwardedFromChatType?: string;
+    ForwardedFromMessageId?: number;
+    ForwardedDate?: number;
+    ThreadStarterBody?: string;
+    /** Full thread history when starting a new thread session. */
+    ThreadHistoryBody?: string;
+    IsFirstThreadTurn?: boolean;
+    ThreadLabel?: string;
+    MediaPath?: string;
+    MediaUrl?: string;
+    MediaType?: string;
+    MediaDir?: string;
+    MediaPaths?: string[];
+    MediaUrls?: string[];
+    MediaTypes?: string[];
+    /** Telegram sticker metadata (emoji, set name, file IDs, cached description). */
+    Sticker?: StickerMetadata;
+    OutputDir?: string;
+    OutputBase?: string;
+    /** Remote host for SCP when media lives on a different machine (e.g., openclaw@192.168.64.3). */
+    MediaRemoteHost?: string;
+    Transcript?: string;
+    MediaUnderstanding?: MediaUnderstandingOutput[];
+    MediaUnderstandingDecisions?: MediaUnderstandingDecision[];
+    LinkUnderstanding?: string[];
+    Prompt?: string;
+    MaxChars?: number;
+    ChatType?: string;
+    /** Human label for envelope headers (conversation label, not sender). */
+    ConversationLabel?: string;
+    GroupSubject?: string;
+    /** Human label for channel-like group conversations (e.g. #general, #support). */
+    GroupChannel?: string;
+    GroupSpace?: string;
+    GroupMembers?: string;
+    GroupSystemPrompt?: string;
+    /** Untrusted metadata that must not be treated as system instructions. */
+    UntrustedContext?: string[];
+    /** Explicit owner allowlist overrides (trusted, configuration-derived). */
+    OwnerAllowFrom?: Array<string | number>;
+    SenderName?: string;
+    SenderId?: string;
+    SenderUsername?: string;
+    SenderTag?: string;
+    SenderE164?: string;
+    Timestamp?: number;
+    /** Provider label (e.g. whatsapp, telegram). */
+    Provider?: string;
+    /** Provider surface label (e.g. discord, slack). Prefer this over `Provider` when available. */
+    Surface?: string;
+    WasMentioned?: boolean;
+    CommandAuthorized?: boolean;
+    CommandSource?: "text" | "native";
+    CommandTargetSessionKey?: string;
+    /** Gateway client scopes when the message originates from the gateway. */
+    GatewayClientScopes?: string[];
+    /** Thread identifier (Telegram topic id or Matrix thread event id). */
+    MessageThreadId?: string | number;
+    /** Telegram forum supergroup marker. */
+    IsForum?: boolean;
+    /**
+     * Originating channel for reply routing.
+     * When set, replies should be routed back to this provider
+     * instead of using lastChannel from the session.
+     */
+    OriginatingChannel?: OriginatingChannelType;
+    /**
+     * Originating destination for reply routing.
+     * The chat/channel/user ID where the reply should be sent.
+     */
+    OriginatingTo?: string;
+    /**
+     * Messages from hooks to be included in the response.
+     * Used for hook confirmation messages like "Session context saved to memory".
+     */
+    HookMessages?: string[];
+};
+export type FinalizedMsgContext = Omit<MsgContext, "CommandAuthorized"> & {
+    /**
+     * Always set by finalizeInboundContext().
+     * Default-deny: missing/undefined becomes false.
+     */
+    CommandAuthorized: boolean;
+};
+export type TemplateContext = MsgContext & {
+    BodyStripped?: string;
+    SessionId?: string;
+    IsNewSession?: string;
+};
+export declare function applyTemplate(str: string | undefined, ctx: TemplateContext): string;

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

@@ -0,0 +1,22 @@
+export type ThinkLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+export type VerboseLevel = "off" | "on" | "full";
+export type NoticeLevel = "off" | "on" | "full";
+export type ElevatedLevel = "off" | "on" | "ask" | "full";
+export type ElevatedMode = "off" | "ask" | "full";
+export type ReasoningLevel = "off" | "on" | "stream";
+export type UsageDisplayLevel = "off" | "tokens" | "full";
+export declare function isBinaryThinkingProvider(provider?: string | null): boolean;
+export declare const XHIGH_MODEL_REFS: readonly ["openai/gpt-5.2", "openai-codex/gpt-5.3-codex", "openai-codex/gpt-5.3-codex-spark", "openai-codex/gpt-5.2-codex", "openai-codex/gpt-5.1-codex", "github-copilot/gpt-5.2-codex", "github-copilot/gpt-5.2"];
+export declare function normalizeThinkLevel(raw?: string | null): ThinkLevel | undefined;
+export declare function supportsXHighThinking(provider?: string | null, model?: string | null): boolean;
+export declare function listThinkingLevels(provider?: string | null, model?: string | null): ThinkLevel[];
+export declare function listThinkingLevelLabels(provider?: string | null, model?: string | null): string[];
+export declare function formatThinkingLevels(provider?: string | null, model?: string | null, separator?: string): string;
+export declare function formatXHighModelHint(): string;
+export declare function normalizeVerboseLevel(raw?: string | null): VerboseLevel | undefined;
+export declare function normalizeNoticeLevel(raw?: string | null): NoticeLevel | undefined;
+export declare function normalizeUsageDisplay(raw?: string | null): UsageDisplayLevel | undefined;
+export declare function resolveResponseUsageMode(raw?: string | null): UsageDisplayLevel;
+export declare function normalizeElevatedLevel(raw?: string | null): ElevatedLevel | undefined;
+export declare function resolveElevatedMode(level?: ElevatedLevel | null): ElevatedMode;
+export declare function normalizeReasoningLevel(raw?: string | null): ReasoningLevel | undefined;

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

@@ -0,0 +1,3 @@
+export declare const HEARTBEAT_TOKEN = "HEARTBEAT_OK";
+export declare const SILENT_REPLY_TOKEN = "NO_REPLY";
+export declare function isSilentReplyText(text: string | undefined, token?: string): boolean;

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

@@ -0,0 +1,8 @@
+type ToolAggregateOptions = {
+    markdown?: boolean;
+};
+export declare function shortenPath(p: string): string;
+export declare function shortenMeta(meta: string): string;
+export declare function formatToolAggregate(toolName?: string, metas?: string[], options?: ToolAggregateOptions): string;
+export declare function formatToolPrefix(toolName?: string, meta?: string): string;
+export {};