@larksuite/openclaw-lark 2025.7.15-beta.0

package/src/card/tool-use-trace-store.js

@@ -0,0 +1,271 @@
+"use strict";
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Runtime store for structured tool-use steps.
+ *
+ * The Feishu card renderer reads from this store by session key so it can
+ * render observable, replayable tool execution without relying purely on
+ * reply payload text.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startToolUseTraceRun = startToolUseTraceRun;
+exports.clearToolUseTraceRun = clearToolUseTraceRun;
+exports.hasToolUseTraceRun = hasToolUseTraceRun;
+exports.recordToolUseStart = recordToolUseStart;
+exports.recordToolUseEnd = recordToolUseEnd;
+exports.getToolUseTraceSteps = getToolUseTraceSteps;
+exports.sanitizeTraceValue = sanitizeTraceValue;
+exports._resetForTesting = _resetForTesting;
+const reasoning_utils_1 = require("./reasoning-utils.js");
+const TRACE_TTL_MS = 30 * 60 * 1000;
+const MAX_SESSION_TRACES = 128;
+const MAX_STEPS_PER_SESSION = 256;
+const STEP_RUNNING_TIMEOUT_MS = 5 * 60 * 1000;
+const GENERIC_STRING_LIMIT = 512;
+const RESULT_STRING_LIMIT = 1024;
+const COMMAND_STRING_LIMIT = 4096;
+const PATH_STRING_LIMIT = 2048;
+const sessionTraces = new Map();
+function startToolUseTraceRun(sessionKey) {
+    if (!sessionKey)
+        return;
+    pruneTraceStore();
+    sessionTraces.set(sessionKey, {
+        nextSeq: 1,
+        updatedAt: Date.now(),
+        steps: [],
+        currentRunId: undefined,
+    });
+}
+function clearToolUseTraceRun(sessionKey) {
+    if (!sessionKey)
+        return;
+    sessionTraces.delete(sessionKey);
+}
+function hasToolUseTraceRun(sessionKey) {
+    if (!sessionKey)
+        return false;
+    return sessionTraces.has(sessionKey);
+}
+function recordToolUseStart(params) {
+    const { sessionKey, toolName, toolParams, toolCallId, runId } = params;
+    if (!sessionKey || !toolName)
+        return;
+    const state = sessionTraces.get(sessionKey);
+    if (!state)
+        return;
+    if (runId) {
+        if (state.currentRunId === undefined) {
+            state.currentRunId = runId;
+        }
+        else if (state.currentRunId !== runId) {
+            return;
+        }
+    }
+    const now = Date.now();
+    if (state.steps.length >= MAX_STEPS_PER_SESSION) {
+        state.steps.splice(0, state.steps.length - MAX_STEPS_PER_SESSION + 1);
+    }
+    state.steps.push({
+        id: `${state.nextSeq}`,
+        seq: state.nextSeq,
+        toolName,
+        toolCallId: toolCallId || undefined,
+        runId: runId || undefined,
+        params: sanitizeTraceValue(toolParams, 0, { source: 'params' }),
+        status: 'running',
+        startedAt: now,
+    });
+    state.nextSeq += 1;
+    state.updatedAt = now;
+}
+function recordToolUseEnd(params) {
+    const { sessionKey, toolName, toolParams, toolCallId, runId, result, error, durationMs } = params;
+    if (!sessionKey || !toolName)
+        return;
+    const state = sessionTraces.get(sessionKey);
+    if (!state)
+        return;
+    if (runId && state.currentRunId !== undefined && state.currentRunId !== runId) {
+        return;
+    }
+    const now = Date.now();
+    const sanitizedParams = sanitizeTraceValue(toolParams, 0, { source: 'params' });
+    const pendingIndex = findPendingStepIndex(state.steps, toolName, sanitizedParams, toolCallId);
+    if (pendingIndex >= 0) {
+        const step = state.steps[pendingIndex];
+        if (!step)
+            return;
+        step.status = error ? 'error' : 'success';
+        step.result = sanitizeTraceValue(result, 0, { source: 'result' });
+        step.error = error ? (0, reasoning_utils_1.truncateText)(error, 160) : undefined;
+        step.durationMs = durationMs;
+        step.finishedAt = now;
+        if (!step.params && sanitizedParams) {
+            step.params = sanitizedParams;
+        }
+        state.updatedAt = now;
+        return;
+    }
+    state.steps.push({
+        id: `${state.nextSeq}`,
+        seq: state.nextSeq,
+        toolName,
+        toolCallId: toolCallId || undefined,
+        runId: runId || undefined,
+        params: sanitizedParams,
+        result: sanitizeTraceValue(result, 0, { source: 'result' }),
+        error: error ? (0, reasoning_utils_1.truncateText)(error, 160) : undefined,
+        durationMs,
+        status: error ? 'error' : 'success',
+        startedAt: now,
+        finishedAt: now,
+    });
+    state.nextSeq += 1;
+    state.updatedAt = now;
+}
+function getToolUseTraceSteps(sessionKey) {
+    if (!sessionKey)
+        return [];
+    const state = sessionTraces.get(sessionKey);
+    if (!state)
+        return [];
+    if (Date.now() - state.updatedAt > TRACE_TTL_MS) {
+        sessionTraces.delete(sessionKey);
+        return [];
+    }
+    const now = Date.now();
+    return state.steps.map((step) => {
+        if (step.status === 'running' && now - step.startedAt > STEP_RUNNING_TIMEOUT_MS) {
+            return { ...step, status: 'error', error: 'timed out', finishedAt: now };
+        }
+        return { ...step };
+    });
+}
+function findPendingStepIndex(steps, toolName, params, toolCallId) {
+    if (toolCallId) {
+        for (let index = steps.length - 1; index >= 0; index -= 1) {
+            const step = steps[index];
+            if (!step || step.status !== 'running')
+                continue;
+            if (step.toolCallId === toolCallId)
+                return index;
+        }
+    }
+    const normalizedToolName = (0, reasoning_utils_1.normalizeToolName)(toolName);
+    const paramsKey = fingerprintTraceValue(params);
+    for (let index = steps.length - 1; index >= 0; index -= 1) {
+        const step = steps[index];
+        if (!step || step.status !== 'running')
+            continue;
+        if ((0, reasoning_utils_1.normalizeToolName)(step.toolName) !== normalizedToolName)
+            continue;
+        if (fingerprintTraceValue(step.params) !== paramsKey)
+            continue;
+        return index;
+    }
+    for (let index = steps.length - 1; index >= 0; index -= 1) {
+        const step = steps[index];
+        if (!step || step.status !== 'running')
+            continue;
+        if ((0, reasoning_utils_1.normalizeToolName)(step.toolName) !== normalizedToolName)
+            continue;
+        return index;
+    }
+    return -1;
+}
+function pruneTraceStore() {
+    const now = Date.now();
+    for (const [sessionKey, state] of sessionTraces) {
+        if (now - state.updatedAt > TRACE_TTL_MS) {
+            sessionTraces.delete(sessionKey);
+        }
+    }
+    if (sessionTraces.size <= MAX_SESSION_TRACES)
+        return;
+    const overflow = sessionTraces.size - MAX_SESSION_TRACES;
+    const entries = [...sessionTraces.entries()].sort((a, b) => a[1].updatedAt - b[1].updatedAt);
+    for (const [sessionKey] of entries.slice(0, overflow)) {
+        sessionTraces.delete(sessionKey);
+    }
+}
+function sanitizeTraceValue(value, depth = 0, context = {}) {
+    if (value == null)
+        return undefined;
+    if (typeof value === 'string') {
+        const limit = resolveStringLimit(context);
+        return (0, reasoning_utils_1.truncateText)(sanitizeTraceString(value, context), limit);
+    }
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return value;
+    if (depth >= 2)
+        return '[truncated]';
+    if (Array.isArray(value)) {
+        return value.slice(0, 8).map((item) => sanitizeTraceValue(item, depth + 1, { source: context.source }));
+    }
+    if (typeof value === 'object') {
+        const input = value;
+        const output = {};
+        for (const [key, entryValue] of Object.entries(input).slice(0, 12)) {
+            output[key] = isSensitiveKey(key)
+                ? '[redacted]'
+                : sanitizeTraceValue(entryValue, depth + 1, { source: context.source, key });
+        }
+        return output;
+    }
+    return (0, reasoning_utils_1.truncateText)(String(value), 180);
+}
+function sanitizeTraceString(value, context) {
+    const redactedUrl = redactUrlParams(value);
+    if (isCommandLikeKey(context.key)) {
+        return (0, reasoning_utils_1.redactInlineSecrets)(redactedUrl);
+    }
+    return redactedUrl;
+}
+function resolveStringLimit(context) {
+    const key = context.key?.toLowerCase() ?? '';
+    if (/(?:^|_)(?:command|script|description|prompt|task)(?:$|_)/.test(key)) {
+        return COMMAND_STRING_LIMIT;
+    }
+    if (/(?:^|_)(?:path|file|url|uri|cwd|folder|dir)(?:$|_)/.test(key)) {
+        return PATH_STRING_LIMIT;
+    }
+    if (context.source === 'result') {
+        return RESULT_STRING_LIMIT;
+    }
+    return GENERIC_STRING_LIMIT;
+}
+function isCommandLikeKey(key) {
+    const normalized = key?.toLowerCase() ?? '';
+    return /(?:^|_)(?:command|script)(?:$|_)/.test(normalized);
+}
+const SENSITIVE_KEY_RE = /secret|token|password|authorization|cookie|api[-_]?key|credential|private[-_]?key|access[-_]?key|database[-_]?url|connection[-_]?string|bearer|signing[-_]?key|encryption[-_]?key|session[-_]?id|client[-_]?secret|auth[-_]?token/i;
+function isSensitiveKey(key) {
+    return SENSITIVE_KEY_RE.test(key);
+}
+function redactUrlParams(url) {
+    return url.replace(/([?&])(api_key|token|secret|key)=[^&]*/gi, '$1$2=[redacted]');
+}
+function fingerprintTraceValue(value) {
+    if (value == null)
+        return '';
+    if (typeof value !== 'object')
+        return String(value);
+    return JSON.stringify(sortTraceValue(value));
+}
+function sortTraceValue(value) {
+    if (Array.isArray(value))
+        return value.map((item) => sortTraceValue(item));
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entryValue]) => [key, sortTraceValue(entryValue)]));
+    }
+    return value;
+}
+/** @internal — test-only helper to reset module-level state between test cases. */
+function _resetForTesting() {
+    sessionTraces.clear();
+}

package/src/card/unavailable-guard.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Guard against operating on unavailable (deleted/recalled) messages.
+ *
+ * Encapsulates the terminateDueToUnavailable / shouldSkipForUnavailable
+ * logic previously scattered as closures in reply-dispatcher.ts.
+ */
+export interface UnavailableGuardParams {
+    replyToMessageId: string | undefined;
+    getCardMessageId: () => string | null;
+    onTerminate: () => void;
+}
+export declare class UnavailableGuard {
+    private terminated;
+    private readonly replyToMessageId;
+    private readonly getCardMessageId;
+    private readonly onTerminate;
+    constructor(params: UnavailableGuardParams);
+    get isTerminated(): boolean;
+    /**
+     * Check whether the reply pipeline should skip further operations.
+     * Returns true if the message is already known to be unavailable.
+     */
+    shouldSkip(source: string): boolean;
+    /**
+     * Attempt to terminate the reply pipeline due to an unavailable message.
+     *
+     * @param source - Descriptive label for the caller (for logging).
+     * @param err    - Optional error that triggered the check.
+     * @returns true if the pipeline was (or already had been) terminated.
+     */
+    terminate(source: string, err?: unknown): boolean;
+}

package/src/card/unavailable-guard.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Guard against operating on unavailable (deleted/recalled) messages.
+ *
+ * Encapsulates the terminateDueToUnavailable / shouldSkipForUnavailable
+ * logic previously scattered as closures in reply-dispatcher.ts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnavailableGuard = void 0;
+const lark_logger_1 = require("../core/lark-logger.js");
+const api_error_1 = require("../core/api-error.js");
+const message_unavailable_1 = require("../core/message-unavailable.js");
+const log = (0, lark_logger_1.larkLogger)('card/unavailable-guard');
+// ---------------------------------------------------------------------------
+// UnavailableGuard
+// ---------------------------------------------------------------------------
+class UnavailableGuard {
+    terminated = false;
+    replyToMessageId;
+    getCardMessageId;
+    onTerminate;
+    constructor(params) {
+        this.replyToMessageId = params.replyToMessageId;
+        this.getCardMessageId = params.getCardMessageId;
+        this.onTerminate = params.onTerminate;
+    }
+    get isTerminated() {
+        return this.terminated;
+    }
+    /**
+     * Check whether the reply pipeline should skip further operations.
+     * Returns true if the message is already known to be unavailable.
+     */
+    shouldSkip(source) {
+        if (this.terminated)
+            return true;
+        if (!this.replyToMessageId)
+            return false;
+        if (!(0, message_unavailable_1.isMessageUnavailable)(this.replyToMessageId))
+            return false;
+        return this.terminate(source);
+    }
+    /**
+     * Attempt to terminate the reply pipeline due to an unavailable message.
+     *
+     * @param source - Descriptive label for the caller (for logging).
+     * @param err    - Optional error that triggered the check.
+     * @returns true if the pipeline was (or already had been) terminated.
+     */
+    terminate(source, err) {
+        if (this.terminated)
+            return true;
+        const fromError = (0, message_unavailable_1.isMessageUnavailableError)(err) ? err : undefined;
+        const cardMessageId = this.getCardMessageId();
+        const state = (0, message_unavailable_1.getMessageUnavailableState)(this.replyToMessageId) ?? (0, message_unavailable_1.getMessageUnavailableState)(cardMessageId ?? undefined);
+        let apiCode = fromError?.apiCode ?? state?.apiCode;
+        if (!apiCode && err) {
+            const detectedCode = (0, api_error_1.extractLarkApiCode)(err);
+            if ((0, message_unavailable_1.isTerminalMessageApiCode)(detectedCode)) {
+                const fallbackMessageId = this.replyToMessageId ?? cardMessageId ?? undefined;
+                if (fallbackMessageId) {
+                    (0, message_unavailable_1.markMessageUnavailable)({
+                        messageId: fallbackMessageId,
+                        apiCode: detectedCode,
+                        operation: source,
+                    });
+                }
+                apiCode = detectedCode;
+            }
+        }
+        if (!apiCode)
+            return false;
+        this.terminated = true;
+        this.onTerminate();
+        const affectedMessageId = fromError?.messageId ?? this.replyToMessageId ?? cardMessageId ?? 'unknown';
+        log.warn('reply pipeline terminated by unavailable message', {
+            source,
+            apiCode,
+            messageId: affectedMessageId,
+        });
+        return true;
+    }
+}
+exports.UnavailableGuard = UnavailableGuard;

package/src/channel/abort-detect.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Abort trigger detection for the Lark/Feishu channel plugin.
+ *
+ * Provides a fast-path check to determine whether an inbound message is
+ * an abort/stop command *before* it enters the per-chat serial queue.
+ *
+ * The trigger word list and normalisation logic are copied from the
+ * OpenClaw core (`src/auto-reply/reply/abort.ts`) so the plugin can
+ * make a lightweight decision without importing the full reply pipeline.
+ * The message still flows through `tryFastAbortFromMessage()` for
+ * authoritative handling.
+ */
+import type { FeishuMessageEvent } from '../messaging/types';
+/** Exact trigger-word match (same logic as OpenClaw core `isAbortTrigger`). */
+export declare function isAbortTrigger(text: string): boolean;
+/**
+ * Extended abort detection: matches both bare trigger words and the
+ * `/stop` command form.  Used by the monitor fast-path.
+ */
+export declare function isLikelyAbortText(text: string): boolean;
+/**
+ * Whether an inbound message expresses intent to stop / interrupt the ongoing
+ * (bot-to-bot) exchange. Superset of {@link isLikelyAbortText} plus the
+ * conversational phrases above.
+ *
+ * Two consumers: (1) suppress the deterministic peer-@ backstop so a stop
+ * acknowledgement doesn't re-wake the peer bot; (2) mute an active bot loop so
+ * the in-flight ping-pong drains instead of being re-armed. Substring match —
+ * keep the list distinctive (no bare "停"/"stop") to limit false positives;
+ * the worst case is a missed forced-@ or a self-healing mute (any normal
+ * message lifts it).
+ */
+export declare function isConversationStopIntent(text: string): boolean;
+/**
+ * Extract the raw text payload from a Feishu message event.
+ *
+ * Only handles `text` type messages.  The `message.content` field is a
+ * JSON string like `{"text":"hello"}`.  Returns `undefined` for
+ * non-text messages or parse failures.
+ *
+ * In group chats, bot mention placeholders (`@_user_N`) are stripped so
+ * a message like `@Bot stop` is detected as `stop`.
+ */
+export declare function extractRawTextFromEvent(event: FeishuMessageEvent): string | undefined;

package/src/channel/abort-detect.js

@@ -0,0 +1,219 @@
+"use strict";
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Abort trigger detection for the Lark/Feishu channel plugin.
+ *
+ * Provides a fast-path check to determine whether an inbound message is
+ * an abort/stop command *before* it enters the per-chat serial queue.
+ *
+ * The trigger word list and normalisation logic are copied from the
+ * OpenClaw core (`src/auto-reply/reply/abort.ts`) so the plugin can
+ * make a lightweight decision without importing the full reply pipeline.
+ * The message still flows through `tryFastAbortFromMessage()` for
+ * authoritative handling.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAbortTrigger = isAbortTrigger;
+exports.isLikelyAbortText = isLikelyAbortText;
+exports.isConversationStopIntent = isConversationStopIntent;
+exports.extractRawTextFromEvent = extractRawTextFromEvent;
+// ---------------------------------------------------------------------------
+// Trigger word list (synced with OpenClaw core abort.ts)
+// ---------------------------------------------------------------------------
+const ABORT_TRIGGERS = new Set([
+    'stop',
+    'esc',
+    'abort',
+    'wait',
+    'exit',
+    'interrupt',
+    'detente',
+    'deten',
+    'detén',
+    'arrete',
+    'arrête',
+    '停止',
+    'やめて',
+    '止めて',
+    'रुको',
+    'توقف',
+    'стоп',
+    'остановись',
+    'останови',
+    'остановить',
+    'прекрати',
+    'halt',
+    'anhalten',
+    'aufhören',
+    'hoer auf',
+    'stopp',
+    'pare',
+    'stop openclaw',
+    'openclaw stop',
+    'stop action',
+    'stop current action',
+    'stop run',
+    'stop current run',
+    'stop agent',
+    'stop the agent',
+    "stop don't do anything",
+    'stop dont do anything',
+    'stop do not do anything',
+    'stop doing anything',
+    'do not do that',
+    'please stop',
+    'stop please',
+]);
+// ---------------------------------------------------------------------------
+// Normalisation helpers
+// ---------------------------------------------------------------------------
+const TRAILING_ABORT_PUNCTUATION_RE = /[.!?…,，。;；:：'"'")\]}]+$/u;
+function normalizeAbortTriggerText(text) {
+    return text
+        .trim()
+        .toLowerCase()
+        .replace(/['`]/g, "'")
+        .replace(/\s+/g, ' ')
+        .replace(TRAILING_ABORT_PUNCTUATION_RE, '')
+        .trim();
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/** Exact trigger-word match (same logic as OpenClaw core `isAbortTrigger`). */
+function isAbortTrigger(text) {
+    if (!text)
+        return false;
+    const normalized = normalizeAbortTriggerText(text);
+    return ABORT_TRIGGERS.has(normalized);
+}
+/**
+ * Extended abort detection: matches both bare trigger words and the
+ * `/stop` command form.  Used by the monitor fast-path.
+ */
+function isLikelyAbortText(text) {
+    if (!text)
+        return false;
+    const trimmed = text.trim().toLowerCase();
+    if (trimmed === '/stop')
+        return true;
+    return isAbortTrigger(trimmed);
+}
+// ---------------------------------------------------------------------------
+// Conversation stop-intent (broader than the exact abort triggers)
+// ---------------------------------------------------------------------------
+/**
+ * Conversational "please stop / interrupt this exchange" phrases.
+ *
+ * Deliberately SEPARATE from {@link ABORT_TRIGGERS} (which is synced word-for-
+ * word with OpenClaw core and matched by exact equality, e.g. `/stop`). These
+ * are matched by substring so natural phrasings like "中断对话" or "stop
+ * talking" are caught. The list is intentionally distinctive to avoid false
+ * positives — a false positive only means we skip the deterministic peer-@
+ * backstop for that turn (the model can still @ on its own), which is mild.
+ */
+const STOP_INTENT_PHRASES = [
+    // zh — stop / terminate / pause
+    '中断',
+    '中止',
+    '终止',
+    '停止',
+    '停下',
+    '停一下',
+    '暂停',
+    '打住',
+    '停手',
+    '收手',
+    // zh — "don't keep going / replying"
+    '别聊',
+    '别说了',
+    '别回复',
+    '别继续',
+    '别再聊',
+    '别再说',
+    '别吵',
+    '别争',
+    '不要回复',
+    '不要继续',
+    '不用回复',
+    '不用继续',
+    // zh — "wrap up / be quiet"
+    '结束对话',
+    '结束讨论',
+    '结束辩论',
+    '到此为止',
+    '闭嘴',
+    // en
+    'stop talking',
+    'stop chatting',
+    'stop debating',
+    'stop the debate',
+    'stop the conversation',
+    'stop this conversation',
+    'stop responding',
+    'stop replying',
+    'end the conversation',
+    'end conversation',
+    'end the debate',
+    'shut up',
+    'be quiet',
+    'cut it out',
+    'knock it off',
+    'wrap it up',
+    'stand down',
+];
+/**
+ * Whether an inbound message expresses intent to stop / interrupt the ongoing
+ * (bot-to-bot) exchange. Superset of {@link isLikelyAbortText} plus the
+ * conversational phrases above.
+ *
+ * Two consumers: (1) suppress the deterministic peer-@ backstop so a stop
+ * acknowledgement doesn't re-wake the peer bot; (2) mute an active bot loop so
+ * the in-flight ping-pong drains instead of being re-armed. Substring match —
+ * keep the list distinctive (no bare "停"/"stop") to limit false positives;
+ * the worst case is a missed forced-@ or a self-healing mute (any normal
+ * message lifts it).
+ */
+function isConversationStopIntent(text) {
+    if (!text)
+        return false;
+    // Drop bot mention placeholders so "@Bot 中断对话" → "中断对话".
+    const normalized = text
+        .replace(/@_user_\d+/g, '')
+        .trim()
+        .toLowerCase();
+    if (!normalized)
+        return false;
+    if (isLikelyAbortText(normalized))
+        return true;
+    return STOP_INTENT_PHRASES.some((p) => normalized.includes(p));
+}
+/**
+ * Extract the raw text payload from a Feishu message event.
+ *
+ * Only handles `text` type messages.  The `message.content` field is a
+ * JSON string like `{"text":"hello"}`.  Returns `undefined` for
+ * non-text messages or parse failures.
+ *
+ * In group chats, bot mention placeholders (`@_user_N`) are stripped so
+ * a message like `@Bot stop` is detected as `stop`.
+ */
+function extractRawTextFromEvent(event) {
+    if (!event.message || event.message.message_type !== 'text') {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(event.message.content);
+        let text = parsed?.text;
+        if (typeof text !== 'string')
+            return undefined;
+        // Strip bot mention placeholders (@_user_1, @_user_2, etc.)
+        text = text.replace(/@_user_\d+/g, '').trim();
+        return text || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}