openclaw-lark-multi-agent 1.8.19 → 1.8.21

package/dist/config.d.ts

@@ -1,12 +1,26 @@
 import { type Locale } from "./i18n.js";
+/** Profile used by a bot that does not name one.
+ *
+ * Keeps every pre-profile configuration on the historical default. */
+export declare const DEFAULT_BOT_PROFILE = "main";
 export interface BotConfig {
     name: string;
     appId: string;
     appSecret: string;
-    model: string;
+    /** Model routed for this bot. Optional: when absent or blank the bot
+     * follows the model of its OpenClaw profile instead of overriding it. */
+    model?: string;
     locale?: Locale;
     /** Optional per-bot thinking level (informational fallback for footers). */
     thinking?: string;
+    /** OpenClaw agent/profile that owns this bot's sessions.
+     *
+     * Optional for backward compatibility: a bot that does not name a profile
+     * keeps the historical `main` profile, so existing configs behave exactly
+     * as before. When set, the bot's sessions are addressed under that
+     * profile, giving it that profile's own workspace, memory and identity.
+     * Defaults to "main" when absent or blank. */
+    profile?: string;
 }
 export interface OpenClawConfig {
     baseUrl: string;

package/dist/config.js

@@ -1,6 +1,10 @@
 import { readFileSync, writeFileSync } from "fs";
 import { resolve } from "path";
 import { normalizeLocale } from "./i18n.js";
+/** Profile used by a bot that does not name one.
+ *
+ * Keeps every pre-profile configuration on the historical default. */
+export const DEFAULT_BOT_PROFILE = "main";
 export function loadConfig(path) {
     const configPath = path || resolve(process.cwd(), "config.json");
     const raw = readFileSync(configPath, "utf-8");
@@ -12,13 +16,21 @@ export function loadConfig(path) {
         throw new Error("No bots configured");
     }
     for (const bot of config.bots) {
-        if (!bot.appId || !bot.appSecret || !bot.model) {
-            throw new Error(`Bot "${bot.name}" missing appId, appSecret, or model`);
+        if (!bot.appId || !bot.appSecret) {
+            throw new Error(`Bot "${bot.name}" missing appId or appSecret`);
         }
     }
     config.locale = normalizeLocale(config.locale);
     for (const bot of config.bots) {
         bot.locale = normalizeLocale(bot.locale || config.locale);
+        // A bot without a profile keeps the historical `main` profile. Older
+        // configs stay byte-identical in behaviour; a profile is only a routing
+        // choice, never a required field.
+        const profile = String(bot.profile == null ? "" : bot.profile).trim();
+        bot.profile = profile || DEFAULT_BOT_PROFILE;
+        // An empty model means "follow the profile's own model".
+        const model = String(bot.model == null ? "" : bot.model).trim();
+        bot.model = model || undefined;
     }
     // Validate uniqueness
     const names = config.bots.map((b) => b.name);

package/dist/feishu-bot.d.ts

@@ -93,8 +93,6 @@ export declare class FeishuBot {
     private deliveryRetryTimers;
     /** Last time a real assistant-visible reply was successfully handed to the delivery pipeline. */
     private lastRealDeliveryAt;
-    /** Per-chat: whether we've already sent the high-context alert this cycle. */
-    private contextAlerted;
     /** Active pre-admission target for the current chat operation. */
     private activeDeliveryTargets;
     /** Stable targets for concurrent runs in one chat. A steer admission can
@@ -120,7 +118,21 @@ export declare class FeishuBot {
      * Get the session key for a specific chat.
      * Format: lma-<botname>-<chatId>
      */
+    /** OpenClaw profile that owns this bot's sessions.
+     *
+     * Defaults to "main" so a configuration written before profiles existed
+     * keeps its historical behaviour exactly. */
+    private get profile();
     getSessionKey(chatId: string): string;
+    /** Physical session key for this bot: the logical key addressed under the
+     * bot's OpenClaw profile.
+     *
+     * The LOGICAL key (getSessionKey) stays profile-free so durable records keep
+     * their historical shape and never need a migration. Every key that is
+     * actually handed to the Gateway goes through this method, so a bot bound to
+     * a non-default profile owns its sessions under that profile (its own
+     * workspace, memory and identity) while the stored records stay compatible. */
+    physicalSessionKey(chatId: string): string;
     private chatLocale;
     private isEn;
     private lmaBridgePolicy;
@@ -164,6 +176,14 @@ export declare class FeishuBot {
     private handleResolvedMessage;
     /** Separate guarded-admission proof. Aggregate busy never becomes idle. */
     private observedFollowupGuard;
+    /** How long an unconfirmed input may stay silent before the user is told.
+     *
+     * A fixed 60s window misfired on every slow session: measured reply latency
+     * in a busy group was p50 3.8min / p90 20.2min / max 135min, so 85% of real
+     * replies exceeded the old threshold and every one of them produced a false
+     * "not confirmed" notice. Scale the window with the session's own observed
+     * latency so a healthy slow run is never reported as stuck. */
+    private unconfirmedGraceMs;
     /** A positive refusal must be durable AND explained to the sender. */
     private retainChangedFollowup;
     private explainUnconfirmedFollowup;
@@ -266,11 +286,15 @@ export declare class FeishuBot {
      *  or 0 if it cannot be determined. Same basis as /status. */
     private getContextUsagePercent;
     /**
-     * After a reply is delivered, alert the user once if context usage crossed the
-     * threshold (default 80%), so they can compact before a session bloats into the
-     * timeout/lock/overflow failure modes. We only alert on a fresh crossing: once
-     * alerted we stay quiet until usage drops back below the threshold (e.g. after
-     * a compact), then re-arm.
+     * After a message completes, alert the user when context usage is at or above
+     * the threshold (default 80%), so they can compact before the session bloats
+     * into the timeout/lock/overflow failure modes.
+     *
+     * The check runs after EVERY completed message and re-notifies on every message
+     * while usage stays above the threshold. There is deliberately no per-chat
+     * "already warned" latch: with one, a single failed send (or a stale latch) would
+     * silently suppress every later warning, and the user would stop being told to
+     * compact while their context keeps growing.
      */
     private maybeAlertHighContext;
     /** True when the agent's reply is exactly a completion phrase (zh or en,
@@ -305,6 +329,11 @@ export declare class FeishuBot {
     private deliverySourceId;
     private sendSystemDelivery;
     private enqueueAndDispatchDelivery;
+    private scopeRunError;
+    /** Shared original-error authorization for journaled terminals AND ordinary
+     * admitted provider errors. Current outbox/config metadata is not authority
+     * to replace the retained admission route or physical target. */
+    private errorRouteRevocation;
     private inspectErrorNotice;
     private deferErrorNotice;
     private scheduleErrorNoticeCheck;
@@ -337,6 +366,8 @@ export declare class FeishuBot {
     private fetchThinkingLabel;
     private asDiscussionParticipant;
     private runDiscussionTurn;
+    private liveInputElements;
+    private liveStatusRequest;
     private buildLiveStatusCard;
     /** Minimal escaping so activity text does not break card markdown. */
     private escapeCardText;
@@ -479,6 +510,12 @@ export declare class FeishuBot {
      * runs for the session, clears the busy lock and every pending trigger, and
      * resets stuck reactions so new messages are processed normally again.
      */
+    /** Release every peer bot's in-memory scheduling state for one chat.
+     * Each bot instance keeps its own queueRuns / queueOwners / busyChats /
+     * pendingAckMessages maps; a durable row cleanup cannot reach those. A
+     * group-scoped /stop must retire them too, otherwise the peer's queue owner
+     * survives and its next message is treated as "busy" forever. */
+    private releasePeerBotsForChat;
     private handleStopCommand;
     /**
      * Fetch chat info (name, type, members) via Feishu API and cache in SQLite.
@@ -502,5 +539,8 @@ export declare class FeishuBot {
     /**
      * Extract text content from a rich text (post) message.
      */
+    /** Visible rich-post fragments only. Text nodes remain literal; only actual
+     * media nodes become type markers, never a regex over the user's prose. */
+    private visiblePostInput;
     private extractPostText;
 }