@nettee/beacon 0.2.6 → 0.2.8

package/dist/feishu/intake.js

@@ -1,3 +1,4 @@
+import { shouldProcessFeishuInbound } from "./mentions.js";
 import { buildFeishuTriggerInput, } from "./trigger-input.js";
 export class FeishuIntake {
     options;
@@ -10,6 +11,16 @@ export class FeishuIntake {
             (event.message.chat_type !== "p2p" && event.message.chat_type !== "group")) {
             return "ignored";
         }
+        // Temporary hard cut: group @All (without a direct bot @) never claims or runs.
+        if (!shouldProcessFeishuInbound({
+            chatType: event.message.chat_type,
+            mentions: event.message.mentions,
+            messageType: event.message.message_type,
+            content: event.message.content,
+        })) {
+            console.log(`[beacon] ignored group event without direct bot mention message_id=${event.message.message_id}`);
+            return "ignored";
+        }
         if (!event.event_id)
             throw new Error("Feishu event_id is required");
         const claim = await this.options.store.claim({

package/dist/feishu/mentions.js

@@ -0,0 +1,102 @@
+/**
+ * Temporary hard cut: group @All must not start a Beacon run.
+ * Prefer Feishu `message.mentions`; fall back to content placeholders.
+ */
+function normalize(value) {
+    return value?.trim().toLowerCase() ?? "";
+}
+/** True when a Feishu mention entry is @All / @所有人 / @_all. */
+export function isFeishuAtAllMention(mention) {
+    const key = normalize(mention.key);
+    if (key === "@_all" || key === "@all")
+        return true;
+    const name = mention.name?.trim() ?? "";
+    const nameLower = name.toLowerCase();
+    if (name === "所有人" || nameLower === "all" || nameLower === "@all") {
+        return true;
+    }
+    const userId = normalize(mention.id?.user_id);
+    if (userId === "all" || userId === "@_all")
+        return true;
+    const openId = mention.id?.open_id?.trim() ?? "";
+    const unionId = mention.id?.union_id?.trim() ?? "";
+    // Empty-identity @_all-shaped rows sometimes omit a clean key.
+    if (!openId &&
+        !unionId &&
+        !userId &&
+        (key.includes("all") || name.includes("所有人"))) {
+        return true;
+    }
+    return false;
+}
+function walkForAtAll(value) {
+    if (typeof value === "string") {
+        const trimmed = value.trim().toLowerCase();
+        return (trimmed === "@_all" ||
+            trimmed === "@all" ||
+            trimmed === "all" ||
+            /@_all\b/i.test(value));
+    }
+    if (Array.isArray(value)) {
+        return value.some((entry) => walkForAtAll(entry));
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        if (record.tag === "at") {
+            const userId = normalize(typeof record.user_id === "string" ? record.user_id : undefined);
+            if (userId === "all" || userId === "@_all")
+                return true;
+        }
+        return Object.values(record).some((entry) => walkForAtAll(entry));
+    }
+    return false;
+}
+/** Detect @_all / at-all markers inside raw Feishu message content JSON. */
+export function contentIndicatesFeishuAtAll(content) {
+    if (!content)
+        return false;
+    if (/@_all\b/i.test(content))
+        return true;
+    try {
+        return walkForAtAll(JSON.parse(content));
+    }
+    catch {
+        return /@_all\b/i.test(content);
+    }
+}
+/**
+ * A direct bot (or other entity) @mention — anything in `mentions` that is not @All.
+ * With mention-only Feishu scopes, non-@All mentions are the bot itself.
+ */
+export function hasDirectFeishuMention(mentions) {
+    if (!mentions?.length)
+        return false;
+    return mentions.some((mention) => {
+        if (isFeishuAtAllMention(mention))
+            return false;
+        if (mention.mentioned_type === "bot")
+            return true;
+        // Explicit user @ is not a bot mention.
+        if (mention.mentioned_type === "user")
+            return false;
+        const openId = mention.id?.open_id?.trim() ?? "";
+        const userId = mention.id?.user_id?.trim() ?? "";
+        const unionId = mention.id?.union_id?.trim() ?? "";
+        // mentioned_type omitted: any non-@All identity counts (mention-only bots).
+        return Boolean(openId || userId || unionId);
+    });
+}
+/**
+ * Beacon-layer gate for inbound Feishu events.
+ * - DM (p2p): always process
+ * - Group: process only when a non-@All mention is present
+ * - Pure @All (with or without @_all content): ignore
+ * - @All + @bot together: process (direct mention wins)
+ */
+export function shouldProcessFeishuInbound(input) {
+    if (input.chatType === "p2p")
+        return true;
+    if (input.chatType !== "group")
+        return false;
+    return hasDirectFeishuMention(input.mentions);
+}

package/dist/run/orchestrator.js

@@ -40,13 +40,54 @@ function summary(error) {
     const value = error instanceof Error ? error.message : String(error);
     return value.slice(0, 4096) || "unknown failure";
 }
-/** User-visible (Feishu/admin) failure text. Keep codes stable; explain missing outcomes. */
+const FAILURE_DETAIL_LIMIT = 400;
+const THINKING_SNIPPET_LIMIT = 120;
+function clipForFeishu(value, max) {
+    const trimmed = value.replace(/\s+/g, " ").trim();
+    if (trimmed.length <= max)
+        return trimmed;
+    return `${trimmed.slice(0, Math.max(0, max - 1))}…`;
+}
+/** Compact settle-side hint for outcome_missing (Feishu / admin). */
+export function formatSettleFailureHint(parts) {
+    const bits = [];
+    if (parts.stopReason?.trim()) {
+        bits.push(`末轮 stopReason=${parts.stopReason.trim()}`);
+    }
+    const thought = parts.thinking?.trim() || parts.text?.trim();
+    if (thought) {
+        bits.push(`thinking：「${clipForFeishu(thought, THINKING_SNIPPET_LIMIT)}」`);
+    }
+    return bits.length > 0 ? bits.join("；") : undefined;
+}
+function detailBeyondMissingSummary(summaryText) {
+    if (summaryText === MISSING_REPLY_OUTCOME_SUMMARY)
+        return undefined;
+    if (summaryText.startsWith(MISSING_REPLY_OUTCOME_SUMMARY)) {
+        const rest = summaryText
+            .slice(MISSING_REPLY_OUTCOME_SUMMARY.length)
+            .replace(/^[\s.;]+/, "")
+            .trim();
+        return rest ? clipForFeishu(rest, FAILURE_DETAIL_LIMIT) : undefined;
+    }
+    return clipForFeishu(summaryText, FAILURE_DETAIL_LIMIT);
+}
+/** User-visible (Feishu/admin) failure text. Keep codes stable; prefer concrete reasons. */
 export function formatFailureReplyText(runId, failure) {
     if (failure?.code === "outcome_missing") {
-        return [
+        const parts = [
             `处理失败（run_id=${runId}，code=outcome_missing）：`,
             "期望恰好调用一次 `reply` 或 `no_reply`，但 Agent 已结束且两者均未提交。",
-        ].join("");
+        ];
+        const detail = failure.summary
+            ? detailBeyondMissingSummary(failure.summary)
+            : undefined;
+        if (detail)
+            parts.push(`详情：${detail}`);
+        return parts.join("");
+    }
+    if (failure?.summary?.trim()) {
+        return `处理失败（run_id=${runId}，code=${failure.code}）：${clipForFeishu(failure.summary, FAILURE_DETAIL_LIMIT)}`;
     }
     if (failure) {
         return `处理失败（run_id=${runId}，code=${failure.code}），请查看 Beacon 本地记录。`;
@@ -182,10 +223,15 @@ export class RunOrchestrator {
             await this.deliverField(triggerKey, "notifyDelivery", current.notifyTarget, outcome.notify, create && current.notifyDelivery === undefined);
         }
     }
-    async fail(triggerKey, runId, code, error, submitted) {
-        const detail = isMissingReplyOutcomeError(error)
+    async fail(triggerKey, runId, code, error, submitted, settle) {
+        let detail = isMissingReplyOutcomeError(error)
             ? MISSING_REPLY_OUTCOME_SUMMARY
             : summary(error);
+        if (code === "outcome_missing") {
+            const hint = formatSettleFailureHint(settle ?? {});
+            if (hint)
+                detail = `${detail}. ${hint}`;
+        }
         const failure = { code, summary: detail };
         await this.options.store.update(triggerKey, (current) => ({
             ...current,
@@ -236,6 +282,7 @@ export class RunOrchestrator {
             run: { ...current.run, state: "running" },
         }));
         const submission = this.options.outcomes.openRun();
+        let settle;
         try {
             const completion = await this.options.runAgent({
                 prompt: promptFor(input),
@@ -250,6 +297,11 @@ export class RunOrchestrator {
                     name: `Beacon ${this.options.profile.id} ${runId}`,
                 },
             });
+            settle = {
+                stopReason: completion.stopReason,
+                thinking: completion.thinking,
+                text: completion.text,
+            };
             const submitted = submission.takeFeedback();
             const outcome = normalizeAgentOutcome(input, submission.take(), record.notifyTarget);
             await this.options.store.update(triggerKey, (current) => ({
@@ -278,7 +330,7 @@ export class RunOrchestrator {
                 : isMissingReplyOutcomeError(error)
                     ? "outcome_missing"
                     : "runtime_exit_failed";
-            await this.fail(triggerKey, runId, code, error, submitted);
+            await this.fail(triggerKey, runId, code, error, submitted, settle);
         }
     }
     async process(triggerKey, normalize) {

package/dist/runtime/pi-rpc.js

@@ -45,6 +45,27 @@ function collectText(message) {
         .join("")
         .trim();
 }
+/** Collect thinking / reasoning blocks from an assistant message content array. */
+export function collectThinking(content) {
+    return content
+        .map((block) => {
+        if (!isObject(block))
+            return "";
+        if (block.type === "thinking") {
+            if (typeof block.thinking === "string")
+                return block.thinking;
+            if (typeof block.text === "string")
+                return block.text;
+        }
+        if (block.type === "reasoning" && typeof block.text === "string") {
+            return block.text;
+        }
+        return "";
+    })
+        .filter((part) => part.trim().length > 0)
+        .join("\n")
+        .trim();
+}
 function buildArguments(request) {
     const args = ["--mode", "rpc", "--no-approve"];
     if (request.session) {
@@ -257,10 +278,13 @@ export async function runPiAgent(request, options = {}) {
                         fail(new Error("Pi completed without a textual final response"));
                         return;
                     }
+                    const thinking = collectThinking(finalMessage.content);
                     const result = {
                         text,
                         provider: finalMessage.provider,
                         model: finalMessage.model,
+                        stopReason: finalMessage.stopReason,
+                        ...(thinking ? { thinking } : {}),
                     };
                     finished = true;
                     clearTimeout(timer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nettee/beacon",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "A single-host bridge from messaging and schedules to isolated agent runs",
   "license": "Apache-2.0",
   "repository": {