// Slack plugin module implements prepare thread context behavior.

import { formatInboundEnvelope } from "openclaw/plugin-sdk/channel-inbound";

import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";

import type { ContextVisibilityMode } from "openclaw/plugin-sdk/config-contracts";

import type { ContextVisibilityMode, OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";

import { logVerbose } from "openclaw/plugin-sdk/runtime-env";

import {

filterSupplementalContextItems,

import type { ResolvedSlackAccount } from "../../accounts.js";

import type { SlackMessageEvent } from "../../types.js";

import { resolveSlackAllowListMatch } from "../allow-list.js";

import { readSessionUpdatedAt } from "../config.runtime.js";

import { readSessionUpdatedAt, resolveChannelResetConfig } from "../config.runtime.js";

import type { SlackMonitorContext } from "../context.js";

import type { SlackMediaResult } from "../media-types.js";

import { resolveSlackThreadHistory, type SlackThreadStarter } from "../thread.js";

type SlackThreadContextData = {

threadStarterBody: string | undefined;

threadHistoryBody: string | undefined;

threadSessionPreviousTimestamp: number | undefined;

shouldSeedInitialThreadContext: boolean;

threadLabel: string | undefined;

threadStarterMedia: SlackMediaResult[] | null;

};

const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;

type SlackSessionResetFreshness = {

state: "missing" | "fresh" | "stale";

};

type SlackSessionFreshnessRuntime = {

session?: {

resolveEntryResetFreshness?: (params: {

storePath?: string;

sessionKey: string;

sessionCfg?: OpenClawConfig["session"];

resetType: "thread";

resetOverride?: ReturnType<typeof resolveChannelResetConfig>;

}) => SlackSessionResetFreshness;

};

};

function resolveSlackThreadSessionFreshness(params: {

ctx: SlackMonitorContext;

storePath: string;

sessionKey: string;

}): SlackSessionResetFreshness | undefined {

// Gateway startup supplies the full channel runtime, but the public surface

// intentionally keeps non-context helpers untyped for external plugins.

const runtime = params.ctx.channelRuntime as SlackSessionFreshnessRuntime | undefined;

return runtime?.session?.resolveEntryResetFreshness?.({

storePath: params.storePath,

sessionKey: params.sessionKey,

sessionCfg: params.ctx.cfg.session,

resetType: "thread",

resetOverride: resolveChannelResetConfig({

sessionCfg: params.ctx.cfg.session,

channel: "slack",

}),

});

}

function isSlackThreadContextSenderAllowed(params: {

allowFromLower: string[];

allowNameMatching: boolean;

let threadHistoryBody: string | undefined;

let threadLabel: string | undefined;

let threadStarterMedia: SlackMediaResult[] | null = null;

const threadSessionPreviousTimestamp =

const threadSessionFreshness =

params.isThreadReply && params.threadTs

? resolveSlackThreadSessionFreshness({

ctx: params.ctx,

storePath: params.storePath,

sessionKey: params.sessionKey,

})

: undefined;

const threadSessionPreviousTimestamp =

params.isThreadReply && params.threadTs && !threadSessionFreshness

? readSessionUpdatedAt({

storePath: params.storePath,

sessionKey: params.sessionKey,

})

: undefined;

const shouldSeedInitialThreadContext = Boolean(

params.isThreadReply &&

params.threadTs &&

(threadSessionFreshness

? threadSessionFreshness.state !== "fresh"

: threadSessionPreviousTimestamp === undefined),

);

const shouldLoadInitialThreadHistory =

shouldSeedInitialThreadContext || params.forceInitialHistory === true;

if (!params.isThreadReply || !params.threadTs) {

return {

threadStarterBody,

threadHistoryBody,

threadSessionPreviousTimestamp,

shouldSeedInitialThreadContext,

threadLabel,

threadStarterMedia,

};

threadLabel = `Slack thread ${params.roomLabel}`;

}

const isNewThreadSession = !threadSessionPreviousTimestamp;

const includeBotStarterAsRootContext = shouldIncludeBotThreadStarterContext({

starterIsCurrentBot,

isNewThreadSession,

isNewThreadSession: shouldSeedInitialThreadContext,

hasStarterText: Boolean(starter?.text),

});

const threadInitialHistoryLimit = params.account.config?.thread?.initialHistoryLimit ?? 20;

if (

threadInitialHistoryLimit > 0 &&

(!threadSessionPreviousTimestamp || params.forceInitialHistory)

) {

if (threadInitialHistoryLimit > 0 && shouldLoadInitialThreadHistory) {

const currentBotRootTs = starter?.ts ?? params.threadTs;

const threadHistory = await resolveSlackThreadHistory({

channelId: params.message.channel,

return {

threadStarterBody,

threadHistoryBody,

threadSessionPreviousTimestamp,

shouldSeedInitialThreadContext,

threadLabel,

threadStarterMedia,

};