remoteclaw 0.0.0 → 0.0.1

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

@@ -0,0 +1,49 @@
+/**
+ * Template interpolation for response prefix.
+ *
+ * Supports variables like `{model}`, `{provider}`, 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;
+    /** 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} | {provider}]", {
+ *   model: "gpt-5.2",
+ *   provider: "openai-codex"
+ * })
+ * // Returns: "[gpt-5.2 | openai-codex]"
+ */
+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 { RemoteClawConfig } 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: RemoteClawConfig;
+    /** 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-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,4 @@
+import { persistSessionUsageUpdate } from "./session-usage.js";
+type PersistRunSessionUsageParams = Parameters<typeof persistSessionUsageUpdate>[0];
+export declare function persistRunSessionUsage(params: PersistRunSessionUsageParams): Promise<void>;
+export {};

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

@@ -0,0 +1,8 @@
+import type { RemoteClawConfig } from "../../config/config.js";
+export declare function prependSystemEvents(params: {
+    cfg: RemoteClawConfig;
+    sessionKey: string;
+    isMainSession: boolean;
+    isNewSession: boolean;
+    prefixedBodyBase: string;
+}): Promise<string>;

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 { RemoteClawConfig } 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: RemoteClawConfig;
+    commandAuthorized: boolean;
+}): Promise<SessionInitResult>;

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

@@ -0,0 +1,27 @@
+/**
+ * Strips RemoteClaw-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;
+export declare function stripLeadingInboundMetadata(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,5 @@
+export { extractVerboseDirective } from "./reply/directives.js";
+export { getReplyFromConfig } from "./reply/get-reply.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/status.d.ts

@@ -0,0 +1,50 @@
+import type { RemoteClawConfig } from "../config/config.js";
+import { type SessionEntry, type SessionScope } from "../config/sessions.js";
+import { formatTokenCount as formatTokenCountShared } from "../utils/usage-format.js";
+import type { VerboseLevel } from "./thinking.js";
+type AgentDefaults = NonNullable<NonNullable<RemoteClawConfig["agents"]>["defaults"]>;
+type AgentConfig = Partial<AgentDefaults>;
+export declare const formatTokenCount: typeof formatTokenCountShared;
+type QueueStatus = {
+    mode?: string;
+    depth?: number;
+    debounceMs?: number;
+    cap?: number;
+    dropPolicy?: string;
+    showDetails?: boolean;
+};
+type StatusArgs = {
+    config?: RemoteClawConfig;
+    agent: AgentConfig;
+    agentId?: string;
+    sessionEntry?: SessionEntry;
+    sessionKey?: string;
+    parentSessionKey?: string;
+    sessionScope?: SessionScope;
+    sessionStorePath?: string;
+    groupActivation?: "mention" | "always";
+    resolvedVerbose?: VerboseLevel;
+    usageLine?: string;
+    timeLine?: string;
+    queue?: QueueStatus;
+    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): Promise<string>;
+export declare function buildHelpMessage(cfg?: RemoteClawConfig): 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?: RemoteClawConfig, options?: CommandsMessageOptions): string;
+export declare function buildCommandsMessagePaginated(cfg?: RemoteClawConfig, options?: CommandsMessageOptions): CommandsMessageResult;
+export {};

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

@@ -0,0 +1,155 @@
+import type { ChannelId } from "../channels/plugins/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;
+    /** Forward origin from the reply target (when reply_to_message is a forwarded message). */
+    ReplyToForwardedFrom?: string;
+    ReplyToForwardedFromType?: string;
+    ReplyToForwardedFromId?: string;
+    ReplyToForwardedFromUsername?: string;
+    ReplyToForwardedFromTitle?: string;
+    ReplyToForwardedDate?: number;
+    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., remoteclaw@192.168.64.3). */
+    MediaRemoteHost?: string;
+    Transcript?: 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,7 @@
+export type VerboseLevel = "off" | "on" | "full";
+export type NoticeLevel = "off" | "on" | "full";
+export type UsageDisplayLevel = "off" | "tokens" | "full";
+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;

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

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

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

@@ -0,0 +1,79 @@
+import type { ImageContent } from "../types/agent-types.js";
+import type { TypingController } from "./reply/typing.js";
+export type BlockReplyContext = {
+    abortSignal?: AbortSignal;
+    timeoutMs?: number;
+};
+/** Context passed to onModelSelected callback with actual model used. */
+export type ModelSelectedContext = {
+    provider: string;
+    model: string;
+};
+export type GetReplyOptions = {
+    /** Override run id for agent events (defaults to random UUID). */
+    runId?: string;
+    /** Abort signal for the underlying agent run. */
+    abortSignal?: AbortSignal;
+    /** Optional inbound images (used for webchat attachments). */
+    images?: ImageContent[];
+    /** Notifies when an agent run actually starts (useful for webchat command handling). */
+    onAgentRunStart?: (runId: string) => void;
+    onReplyStart?: () => Promise<void> | void;
+    /** Called when the typing controller cleans up (e.g., run ended with NO_REPLY). */
+    onTypingCleanup?: () => void;
+    onTypingController?: (typing: TypingController) => void;
+    isHeartbeat?: boolean;
+    /** Resolved heartbeat model override (provider/model string from merged per-agent config). */
+    heartbeatModelOverride?: string;
+    /** If true, suppress tool error warning payloads for this run. */
+    suppressToolErrorWarnings?: boolean;
+    onPartialReply?: (payload: ReplyPayload) => Promise<void> | void;
+    onReasoningStream?: (payload: ReplyPayload) => Promise<void> | void;
+    /** Called when a thinking/reasoning block ends. */
+    onReasoningEnd?: () => Promise<void> | void;
+    /** Called when a new assistant message starts (e.g., after tool call or thinking block). */
+    onAssistantMessageStart?: () => Promise<void> | void;
+    onBlockReply?: (payload: ReplyPayload, context?: BlockReplyContext) => Promise<void> | void;
+    onToolResult?: (payload: ReplyPayload) => Promise<void> | void;
+    /** Called when a tool phase starts/updates, before summary payloads are emitted. */
+    onToolStart?: (payload: {
+        name?: string;
+        phase?: string;
+    }) => Promise<void> | void;
+    /** Called when the actual model is selected (including after fallback).
+     * Use this to get model/provider for responsePrefix template interpolation. */
+    onModelSelected?: (ctx: ModelSelectedContext) => void;
+    disableBlockStreaming?: boolean;
+    /** Timeout for block reply delivery (ms). */
+    blockReplyTimeoutMs?: number;
+    /** Mutable ref to track if a reply was sent (for Slack "first" threading mode). */
+    hasRepliedRef?: {
+        value: boolean;
+    };
+    /** Override agent timeout in seconds (0 = no timeout). Threads through to resolveAgentTimeoutMs. */
+    timeoutOverrideSeconds?: number;
+};
+/** Structured heartbeat report attached to a reply payload by the agent runner. */
+export type ReplyHeartbeatReport = {
+    anythingDone: boolean;
+    summary?: string | null;
+};
+export type ReplyPayload = {
+    text?: string;
+    mediaUrl?: string;
+    mediaUrls?: string[];
+    replyToId?: string;
+    replyToTag?: boolean;
+    /** True when [[reply_to_current]] was present but not yet mapped to a message id. */
+    replyToCurrent?: boolean;
+    /** Send audio as voice message (bubble) instead of audio file. Defaults to false. */
+    audioAsVoice?: boolean;
+    isError?: boolean;
+    /** Marks this payload as a reasoning/thinking block. Channels that do not
+     *  have a dedicated reasoning lane (e.g. WhatsApp, web) should suppress it. */
+    isReasoning?: boolean;
+    /** Channel-specific payload data (per-channel envelope). */
+    channelData?: Record<string, unknown>;
+    /** Heartbeat report from the heartbeat_report MCP tool (set by agent runner on heartbeat runs). */
+    heartbeatReport?: ReplyHeartbeatReport;
+};

package/dist/plugin-sdk/channel-web.d.ts

@@ -0,0 +1,6 @@
+export { DEFAULT_WEB_MEDIA_BYTES, monitorWebChannel, resolveHeartbeatRecipients, runWebHeartbeatOnce, type WebChannelStatus, type WebMonitorTuning, } from "./web/auto-reply.js";
+export { extractMediaPlaceholder, extractText, monitorWebInbox, type WebInboundMessage, type WebListenerCloseReason, } from "./web/inbound.js";
+export { loginWeb } from "./web/login.js";
+export { loadWebMedia, optimizeImageToJpeg } from "./web/media.js";
+export { sendMessageWhatsApp } from "./web/outbound.js";
+export { createWaSocket, formatError, getStatusCode, logoutWeb, logWebSelfId, pickWebChannel, WA_WEB_AUTH_DIR, waitForWaConnection, webAuthExists, } from "./web/session.js";

package/dist/plugin-sdk/channels/account-summary.d.ts

@@ -0,0 +1,17 @@
+import type { RemoteClawConfig } from "../config/config.js";
+import type { ChannelAccountSnapshot } from "./plugins/types.core.js";
+import type { ChannelPlugin } from "./plugins/types.plugin.js";
+export declare function buildChannelAccountSnapshot(params: {
+    plugin: ChannelPlugin;
+    account: unknown;
+    cfg: RemoteClawConfig;
+    accountId: string;
+    enabled: boolean;
+    configured: boolean;
+}): ChannelAccountSnapshot;
+export declare function formatChannelAllowFrom(params: {
+    plugin: ChannelPlugin;
+    cfg: RemoteClawConfig;
+    accountId?: string | null;
+    allowFrom: Array<string | number>;
+}): string[];

package/dist/plugin-sdk/channels/ack-reactions.d.ts

@@ -0,0 +1,29 @@
+export type AckReactionScope = "all" | "direct" | "group-all" | "group-mentions" | "off" | "none";
+export type WhatsAppAckReactionMode = "always" | "mentions" | "never";
+export type AckReactionGateParams = {
+    scope: AckReactionScope | undefined;
+    isDirect: boolean;
+    isGroup: boolean;
+    isMentionableGroup: boolean;
+    requireMention: boolean;
+    canDetectMention: boolean;
+    effectiveWasMentioned: boolean;
+    shouldBypassMention?: boolean;
+};
+export declare function shouldAckReaction(params: AckReactionGateParams): boolean;
+export declare function shouldAckReactionForWhatsApp(params: {
+    emoji: string;
+    isDirect: boolean;
+    isGroup: boolean;
+    directEnabled: boolean;
+    groupMode: WhatsAppAckReactionMode;
+    wasMentioned: boolean;
+    groupActivated: boolean;
+}): boolean;
+export declare function removeAckReactionAfterReply(params: {
+    removeAfterReply: boolean;
+    ackReactionPromise: Promise<boolean> | null;
+    ackReactionValue: string | null;
+    remove: () => Promise<void>;
+    onError?: (err: unknown) => void;
+}): void;

package/dist/plugin-sdk/channels/allow-from.d.ts

@@ -0,0 +1,11 @@
+export declare function mergeAllowFromSources(params: {
+    allowFrom?: Array<string | number>;
+    storeAllowFrom?: string[];
+    dmPolicy?: string;
+}): string[];
+export declare function firstDefined<T>(...values: Array<T | undefined>): (T & ({} | null)) | undefined;
+export declare function isSenderIdAllowed(allow: {
+    entries: string[];
+    hasWildcard: boolean;
+    hasEntries: boolean;
+}, senderId: string | undefined, allowWhenEmpty: boolean): boolean;