@oyasmi/pipiclaw 0.6.4 → 0.6.6-beta.1

package/README.md

@@ -208,7 +208,9 @@ $env:PIPICLAW_SHELL = "C:\Program Files\Git\bin\bash.exe"
   "robotCode": "",
   "cardTemplateId": "",
   "cardTemplateKey": "content",
-  "allowFrom": []
+  "allowFrom": [],
+  "busyMessageDefault": "steer",
+  "progressDisplay": "full"
 }
 ```
 
@@ -227,6 +229,10 @@ $env:PIPICLAW_SHELL = "C:\Program Files\Git\bin\bash.exe"
   建议配置；留空时表示暂不启用 AI Card
 - `allowFrom`
   设为 `[]` 或删除时表示允许所有人
+- `busyMessageDefault`
+  设为 `"steer"`（默认）或 `"followUp"` / `"followup"`。控制 Agent 忙碌时普通消息的默认处理方式；答疑机器人场景建议设为 `"followUp"`。
+- `progressDisplay`
+  设为 `"full"`（默认）或 `"rolling"`。控制 AI Card 进度展示方式；`"rolling"` 模式下执行中只显示最近 3 条进展，完成后收起为一行摘要。
 
 推荐把 AI Card 一起配上，这样在钉钉里能直接看到过程更新。只有在排查接入链路时，才建议临时把 `cardTemplateId` 留空。
 

package/dist/agent/channel-runner.d.ts

@@ -24,6 +24,7 @@ export declare class ChannelRunner implements AgentRunner {
     private activeModel;
     private currentSkills;
     private firstTurnMemoryBootstrapPending;
+    private acceptingBusyMessages;
     private runState;
     constructor(sandboxConfig: SandboxConfig, channelId: string, channelDir: string);
     run(ctx: DingTalkContext, store: ChannelStore): Promise<{

package/dist/agent/channel-runner.js

@@ -53,6 +53,7 @@ function asSdkSettingsManager(manager) {
 export class ChannelRunner {
     constructor(sandboxConfig, channelId, channelDir) {
         this.firstTurnMemoryBootstrapPending = true;
+        this.acceptingBusyMessages = false;
         // --- Per run ---
         this.runState = createEmptyRunState();
         this.sandboxConfig = sandboxConfig;
@@ -169,8 +170,10 @@ export class ChannelRunner {
     // === Public API ===
     async run(ctx, store) {
         this.resetRunState(ctx, store);
+        this.acceptingBusyMessages = true;
         const runQueue = createRunQueue(ctx);
         this.runState.queue = runQueue.queue;
+        let promptSubmitted = false;
         try {
             await this.ensureSessionReady();
             this.memoryLifecycle.noteUserTurnStarted();
@@ -225,6 +228,7 @@ export class ChannelRunner {
             }
             await this.sessionResourceGate.runPrompt(async () => {
                 await this.session.prompt(promptText);
+                promptSubmitted = true;
             });
         }
         catch (err) {
@@ -233,6 +237,14 @@ export class ChannelRunner {
             log.logWarning(`[${this.channelId}] Runner failed`, this.runState.errorMessage);
         }
         finally {
+            this.acceptingBusyMessages = false;
+            if (!promptSubmitted) {
+                const discarded = this.session.clearQueue();
+                const discardedCount = discarded.steering.length + discarded.followUp.length;
+                if (discardedCount > 0) {
+                    log.logWarning(`[${this.channelId}] Discarded ${discardedCount} queued busy message(s) after run setup failed`);
+                }
+            }
             await runQueue.drain();
             const finalOutcome = this.runState.finalOutcome;
             const finalOutcomeText = getFinalOutcomeText(finalOutcome);
@@ -423,20 +435,28 @@ export class ChannelRunner {
         return `[${timestamp}] [${userName || "unknown"}]: ${text}`;
     }
     async queueBusyMessage(delivery, text, userName) {
-        if (!this.session.isStreaming) {
+        if (!this.acceptingBusyMessages) {
             throw new Error("No task is currently running.");
         }
+        await this.ensureSessionReady();
         const clippedText = clipUserInput(text, MAX_USER_MESSAGE_CHARS);
         if (clippedText !== text.trim()) {
             log.logWarning(`[${this.channelId}] Queued message exceeded ${MAX_USER_MESSAGE_CHARS} chars and was clipped`);
         }
         const queuedMessage = this.formatUserMessage(clippedText, userName);
         await this.maybeRunPreventiveCompactionForIncomingText(queuedMessage);
-        await this.sessionResourceGate.runPrompt(async () => {
-            await this.session.prompt(queuedMessage, {
-                streamingBehavior: delivery,
-            });
-        });
+        if (!this.acceptingBusyMessages) {
+            throw new Error("No task is currently running.");
+        }
+        const queueMessage = async () => {
+            if (delivery === "followUp") {
+                await this.session.followUp(queuedMessage);
+            }
+            else {
+                await this.session.steer(queuedMessage);
+            }
+        };
+        await this.sessionResourceGate.runPrompt(queueMessage);
     }
     resetRunState(ctx, store) {
         this.runState = createEmptyRunState();

package/dist/agent/commands.js

@@ -19,7 +19,9 @@ These are handled directly by the DingTalk transport/runtime layer.
   Queue another request to run after the current task completes
   Example: \`/followup After that, draft a short executive summary\`
 
-While a task is running, a plain message is treated as \`steer\` by default.
+While a task is running, plain messages use the configured busy-message default. The default is \`steer\`; set \`busyMessageDefault\` in channel.json to \`followUp\` or \`followup\` to queue plain messages after the current task.
+
+Set \`progressDisplay\` in channel.json to \`rolling\` for compact AI Card progress: recent entries while running, then a short summary after completion.
 
 ## Session Commands
 

package/dist/index.d.ts

@@ -15,7 +15,7 @@ export { findExactModelReferenceMatch, findModelReferenceMatch, formatModelList,
 export { APP_HOME_DIR, APP_NAME, AUTH_CONFIG_PATH, CHANNEL_CONFIG_PATH, MODELS_CONFIG_PATH, SECURITY_CONFIG_PATH, SETTINGS_CONFIG_PATH, SUB_AGENTS_DIR, SUB_AGENTS_DIR_NAME, TOOLS_CONFIG_PATH, WORKSPACE_DIR, } from "./paths.js";
 export { ensureChannelDir, getChannelDir, getChannelDirName, } from "./runtime/channel-paths.js";
 export { createDingTalkContext } from "./runtime/delivery.js";
-export { type BusyMessageMode, DingTalkBot, type DingTalkConfig, type DingTalkContext, type DingTalkEvent, type DingTalkHandler, } from "./runtime/dingtalk.js";
+export { type BusyMessageDefaultConfig, type BusyMessageMode, DingTalkBot, type DingTalkConfig, type DingTalkContext, type DingTalkEvent, type DingTalkHandler, isBusyMessageDefaultConfig, isProgressDisplayConfig, normalizeBusyMessageDefault, normalizeProgressDisplay, type ProgressDisplayMode, } from "./runtime/dingtalk.js";
 export { createEventsWatcher, type EventAction, EventsWatcher, type ImmediateEvent, type OneShotEvent, type PeriodicEvent, type ScheduledEvent, } from "./runtime/events.js";
 export { ChannelStore, type LoggedMessage, type LoggedSubAgentRun } from "./runtime/store.js";
 export { createExecutor, type ExecOptions, type ExecResult, type Executor, parseSandboxArg, type SandboxConfig, validateSandbox, } from "./sandbox.js";

package/dist/index.js

@@ -15,7 +15,7 @@ export { findExactModelReferenceMatch, findModelReferenceMatch, formatModelList,
 export { APP_HOME_DIR, APP_NAME, AUTH_CONFIG_PATH, CHANNEL_CONFIG_PATH, MODELS_CONFIG_PATH, SECURITY_CONFIG_PATH, SETTINGS_CONFIG_PATH, SUB_AGENTS_DIR, SUB_AGENTS_DIR_NAME, TOOLS_CONFIG_PATH, WORKSPACE_DIR, } from "./paths.js";
 export { ensureChannelDir, getChannelDir, getChannelDirName, } from "./runtime/channel-paths.js";
 export { createDingTalkContext } from "./runtime/delivery.js";
-export { DingTalkBot, } from "./runtime/dingtalk.js";
+export { DingTalkBot, isBusyMessageDefaultConfig, isProgressDisplayConfig, normalizeBusyMessageDefault, normalizeProgressDisplay, } from "./runtime/dingtalk.js";
 export { createEventsWatcher, EventsWatcher, } from "./runtime/events.js";
 export { ChannelStore } from "./runtime/store.js";
 export { createExecutor, parseSandboxArg, validateSandbox, } from "./sandbox.js";

package/dist/runtime/bootstrap.js

@@ -14,7 +14,7 @@ import { formatConfigDiagnostic } from "../shared/config-diagnostics.js";
 import { loadToolsConfigWithDiagnostics } from "../tools/config.js";
 import { ensureChannelDir } from "./channel-paths.js";
 import { createDingTalkContext } from "./delivery.js";
-import { DingTalkBot, } from "./dingtalk.js";
+import { DingTalkBot, isBusyMessageDefaultConfig, isProgressDisplayConfig, normalizeBusyMessageDefault, normalizeProgressDisplay, } from "./dingtalk.js";
 import { createEventsWatcher } from "./events.js";
 import { ChannelStore } from "./store.js";
 const DEFAULT_SOUL = `# SOUL.md
@@ -102,6 +102,8 @@ const CHANNEL_CONFIG_TEMPLATE = {
     cardTemplateId: "your-card-template-id",
     cardTemplateKey: "content",
     allowFrom: ["your-staff-id"],
+    busyMessageDefault: "steer",
+    progressDisplay: "full",
 };
 const MODELS_CONFIG_TEMPLATE = { providers: {} };
 const TOOLS_CONFIG_TEMPLATE = {
@@ -236,6 +238,14 @@ function listChannelConfigIssues(config) {
     if (Array.isArray(config.allowFrom) && config.allowFrom.some((value) => isPlaceholderString(value))) {
         issues.push("Replace placeholder values in `allowFrom`, or set it to an empty array to allow all users.");
     }
+    const busyMessageDefault = config.busyMessageDefault;
+    if (busyMessageDefault !== undefined && !isBusyMessageDefaultConfig(busyMessageDefault)) {
+        issues.push('Invalid `busyMessageDefault`: expected "steer", "followUp", or "followup".');
+    }
+    const progressDisplay = config.progressDisplay;
+    if (progressDisplay !== undefined && !isProgressDisplayConfig(progressDisplay)) {
+        issues.push('Invalid `progressDisplay`: expected "full" or "rolling".');
+    }
     return issues;
 }
 export function printBootstrapSummary(result, io = console, paths = DEFAULT_BOOTSTRAP_PATHS) {
@@ -270,6 +280,8 @@ export function loadConfig(paths = DEFAULT_BOOTSTRAP_PATHS, io = console) {
     }
     parsed.cardTemplateKey = parsed.cardTemplateKey || "content";
     parsed.robotCode = parsed.robotCode?.trim() ? parsed.robotCode : parsed.clientId;
+    parsed.busyMessageDefault = normalizeBusyMessageDefault(parsed.busyMessageDefault);
+    parsed.progressDisplay = normalizeProgressDisplay(parsed.progressDisplay);
     if (Array.isArray(parsed.allowFrom)) {
         parsed.allowFrom = parsed.allowFrom.filter((value) => value.trim().length > 0);
     }
@@ -329,6 +341,9 @@ function flushInactiveChannelMemory(channelStates) {
     }
     return flushes;
 }
+function isNoRunningTaskQueueError(err) {
+    return err instanceof Error && err.message === "No task is currently running.";
+}
 export function createRuntimeContext(options) {
     const startServices = options.startServices ?? true;
     const registerSignalHandlers = options.registerSignalHandlers ?? true;
@@ -378,20 +393,10 @@ export function createRuntimeContext(options) {
         },
         async handleBusyMessage(event, bot, mode, queueText) {
             if (shuttingDown) {
-                return;
+                return true;
             }
             const state = getState(event.channelId);
             const trimmedQueueText = queueText.trim();
-            await archiveIncomingMessage(event.channelId, {
-                date: new Date().toISOString(),
-                ts: event.ts,
-                user: event.user,
-                userName: event.userName,
-                text: event.text,
-                isBot: false,
-                deliveryMode: mode,
-                skipContextSync: true,
-            }, `${mode} message`);
             try {
                 if (mode === "followUp") {
                     await state.runner.queueFollowUp(trimmedQueueText, event.userName);
@@ -399,18 +404,36 @@ export function createRuntimeContext(options) {
                 else {
                     await state.runner.queueSteer(trimmedQueueText, event.userName);
                 }
+                await archiveIncomingMessage(event.channelId, {
+                    date: new Date().toISOString(),
+                    ts: event.ts,
+                    user: event.user,
+                    userName: event.userName,
+                    text: event.text,
+                    isBot: false,
+                    deliveryMode: mode,
+                    skipContextSync: true,
+                }, `${mode} message`);
                 const confirmation = mode === "followUp"
-                    ? "Queued as follow-up. I’ll handle it after the current task completes."
+                    ? event.text.trim().startsWith("/")
+                        ? "Queued as follow-up. I’ll handle it after the current task completes."
+                        : "Queued as follow-up. I’ll handle it after the current task completes. Use `/steer <message>` to apply it after the current tool step finishes."
                     : event.text.trim().startsWith("/")
                         ? "Queued as steer. I’ll apply it after the current tool step finishes."
                         : "Queued as steer. I’ll apply this after the current tool step finishes. Use `/followup <message>` to queue it after completion.";
                 await bot.sendPlain(event.channelId, confirmation);
                 log.logInfo(`[${event.channelId}] Queued ${mode}: ${trimmedQueueText.substring(0, 80)}`);
+                return true;
             }
             catch (err) {
                 const errMsg = err instanceof Error ? err.message : String(err);
+                if (isNoRunningTaskQueueError(err)) {
+                    log.logInfo(`[${event.channelId}] Busy ${mode} window closed; requeueing as a normal message`);
+                    return false;
+                }
                 log.logWarning(`[${event.channelId}] Failed to queue ${mode}`, errMsg);
                 await bot.sendPlain(event.channelId, `Could not queue this message: ${errMsg}`);
+                return true;
             }
         },
         async handleEvent(event, bot, _isEvent) {

package/dist/runtime/delivery.js

@@ -1,5 +1,6 @@
 import * as log from "../log.js";
 const MIN_UPDATE_INTERVAL_MS = 800;
+const ROLLING_WINDOW_SIZE = 3;
 const NO_CONTENT = "";
 class ChannelDeliveryController {
     constructor(event, bot, store) {
@@ -17,7 +18,9 @@ class ChannelDeliveryController {
         this.finalResponseDelivered = false;
         this.cardWarmupScheduled = false;
         this.cardWarmupTriggered = false;
+        this.progressStartedAt = 0;
         this.progressWindowStartedAt = 0;
+        this.toolCallCount = 0;
         this.lastDeliveredAt = 0;
         this.timer = null;
         this.cardWarmupTimer = null;
@@ -97,11 +100,20 @@ class ChannelDeliveryController {
         if (this.closed || this.finalResponseDelivered || !text.trim())
             return;
         this.clearCardWarmup();
+        if (this.progressStartedAt === 0) {
+            this.progressStartedAt = Date.now();
+        }
+        if (text.startsWith("Running:")) {
+            this.toolCallCount++;
+        }
         if (this.progressSegments.length > 0) {
             this.progressSegments.push("\n\n");
         }
         this.progressSegments.push(text);
         this.progressTextDirty = true;
+        if (this.bot.progressDisplay === "rolling") {
+            this.trimToRecentEntries(ROLLING_WINDOW_SIZE);
+        }
         if (this.progressWindowStartedAt === 0) {
             this.progressWindowStartedAt = Date.now();
         }
@@ -213,12 +225,13 @@ class ChannelDeliveryController {
                     }
                     else if (mode === "finalize-existing") {
                         if (content || this.cardWarmupTriggered) {
-                            touchedRemote = await this.bot.replaceCard(this.event.channelId, content ? progressText : NO_CONTENT, true);
+                            const finalProgressText = this.bot.progressDisplay === "rolling" ? this.buildSummaryText("Done") : progressText;
+                            touchedRemote = await this.bot.replaceCard(this.event.channelId, content || this.bot.progressDisplay === "rolling" ? finalProgressText : NO_CONTENT, true);
                             if (!touchedRemote) {
                                 this.bot.discardCard(this.event.channelId);
                             }
                             else {
-                                this.sentProgressChars = progressText.length;
+                                this.sentProgressChars = finalProgressText.length;
                                 this.replayRequired = false;
                             }
                         }
@@ -306,6 +319,36 @@ class ChannelDeliveryController {
         this.progressTextDirty = false;
         return this.cachedProgressText;
     }
+    trimToRecentEntries(maxEntries) {
+        let entryCount = 0;
+        for (const segment of this.progressSegments) {
+            if (segment !== "\n\n") {
+                entryCount++;
+            }
+        }
+        if (entryCount <= maxEntries) {
+            return;
+        }
+        const entriesToRemove = entryCount - maxEntries;
+        let removedEntries = 0;
+        while (removedEntries < entriesToRemove && this.progressSegments.length > 0) {
+            const segment = this.progressSegments.shift();
+            if (segment !== "\n\n") {
+                removedEntries++;
+            }
+        }
+        while (this.progressSegments[0] === "\n\n") {
+            this.progressSegments.shift();
+        }
+        this.progressTextDirty = true;
+        this.replayRequired = true;
+        this.sentProgressChars = 0;
+    }
+    buildSummaryText(status) {
+        const elapsedSeconds = this.progressStartedAt > 0 ? Math.round((Date.now() - this.progressStartedAt) / 1000) : 0;
+        const toolLabel = this.toolCallCount === 1 ? "1 tool call" : `${this.toolCallCount} tool calls`;
+        return `${status} · ${toolLabel} · ${elapsedSeconds}s`;
+    }
 }
 export function createDingTalkContext(event, bot, store) {
     return new ChannelDeliveryController(event, bot, store).buildContext();

package/dist/runtime/dingtalk.d.ts

@@ -1,3 +1,10 @@
+export type BusyMessageMode = "steer" | "followUp";
+export type BusyMessageDefaultConfig = BusyMessageMode | "followup";
+export type ProgressDisplayMode = "full" | "rolling";
+export declare function isBusyMessageDefaultConfig(value: unknown): value is BusyMessageDefaultConfig;
+export declare function isProgressDisplayConfig(value: unknown): value is ProgressDisplayMode;
+export declare function normalizeBusyMessageDefault(value: unknown): BusyMessageMode;
+export declare function normalizeProgressDisplay(value: unknown): ProgressDisplayMode;
 export interface DingTalkConfig {
     clientId: string;
     clientSecret: string;
@@ -6,6 +13,8 @@ export interface DingTalkConfig {
     cardTemplateKey?: string;
     allowFrom?: string[];
     stateDir?: string;
+    busyMessageDefault?: BusyMessageDefaultConfig;
+    progressDisplay?: ProgressDisplayMode;
 }
 export interface DingTalkEvent {
     type: "dm" | "group";
@@ -38,12 +47,11 @@ export interface DingTalkContext {
     flush: () => Promise<void>;
     close: () => Promise<void>;
 }
-export type BusyMessageMode = "steer" | "followUp";
 export interface DingTalkHandler {
     isRunning(channelId: string): boolean;
     handleEvent(event: DingTalkEvent, bot: DingTalkBot, isEvent?: boolean): Promise<void>;
     handleStop(channelId: string, bot: DingTalkBot): Promise<void>;
-    handleBusyMessage(event: DingTalkEvent, bot: DingTalkBot, mode: BusyMessageMode, queueText: string): Promise<void>;
+    handleBusyMessage(event: DingTalkEvent, bot: DingTalkBot, mode: BusyMessageMode, queueText: string): Promise<boolean>;
 }
 export declare class DingTalkBot {
     private handler;
@@ -66,6 +74,8 @@ export declare class DingTalkBot {
     private processedIds;
     private processedIdsOrder;
     constructor(handler: DingTalkHandler, config: DingTalkConfig);
+    get busyMessageDefault(): BusyMessageMode;
+    get progressDisplay(): ProgressDisplayMode;
     /**
      * Mark an ID as processed. Returns true if this is a new ID, false if already seen.
      * Maintains a FIFO buffer of at most 200 entries.
@@ -95,6 +105,7 @@ export declare class DingTalkBot {
      * Returns true if enqueued, false if queue is full (max 5).
      */
     enqueueEvent(event: DingTalkEvent): boolean;
+    private enqueueStreamMessage;
     /**
      * Get or create an AI Card for a channel.
      */

package/dist/runtime/dingtalk.js

@@ -15,6 +15,33 @@ import { parseBuiltInCommand, renderBuiltInHelp } from "../agent/commands.js";
 import * as log from "../log.js";
 import { isRecord } from "../shared/type-guards.js";
 import { getChannelDir } from "./channel-paths.js";
+export function isBusyMessageDefaultConfig(value) {
+    return value === "steer" || value === "followUp" || value === "followup";
+}
+export function isProgressDisplayConfig(value) {
+    return value === "full" || value === "rolling";
+}
+export function normalizeBusyMessageDefault(value) {
+    if (value === undefined) {
+        return "steer";
+    }
+    if (value === "steer") {
+        return "steer";
+    }
+    if (value === "followUp" || value === "followup") {
+        return "followUp";
+    }
+    throw new Error('Invalid `busyMessageDefault`: expected "steer", "followUp", or "followup".');
+}
+export function normalizeProgressDisplay(value) {
+    if (value === undefined) {
+        return "full";
+    }
+    if (isProgressDisplayConfig(value)) {
+        return value;
+    }
+    throw new Error('Invalid `progressDisplay`: expected "full" or "rolling".');
+}
 class ChannelQueue {
     constructor() {
         this.queue = [];
@@ -90,7 +117,17 @@ export class DingTalkBot {
         this.processedIds = new Set();
         this.processedIdsOrder = [];
         this.handler = handler;
-        this.config = config;
+        this.config = {
+            ...config,
+            busyMessageDefault: normalizeBusyMessageDefault(config.busyMessageDefault),
+            progressDisplay: normalizeProgressDisplay(config.progressDisplay),
+        };
+    }
+    get busyMessageDefault() {
+        return normalizeBusyMessageDefault(this.config.busyMessageDefault);
+    }
+    get progressDisplay() {
+        return normalizeProgressDisplay(this.config.progressDisplay);
     }
     /**
      * Mark an ID as processed. Returns true if this is a new ID, false if already seen.
@@ -444,6 +481,18 @@ export class DingTalkBot {
         });
         return true;
     }
+    enqueueStreamMessage(event) {
+        this.getQueue(event.channelId).enqueue(async () => {
+            this.activeMessageProcessing = true;
+            try {
+                await this.handler.handleEvent(event, this);
+            }
+            finally {
+                this.activeMessageProcessing = false;
+                this.lastSocketAvailableTime = Date.now();
+            }
+        });
+    }
     // ==========================================================================
     // AI Card operations
     // ==========================================================================
@@ -821,35 +870,35 @@ export class DingTalkBot {
                 return;
             }
             if (builtInCommand?.name === "steer") {
-                await this.handler.handleBusyMessage(event, this, "steer", builtInCommand.args);
+                const handled = await this.handler.handleBusyMessage(event, this, "steer", builtInCommand.args);
+                if (!handled) {
+                    this.enqueueStreamMessage(event);
+                }
                 return;
             }
             if (builtInCommand?.name === "followup") {
-                await this.handler.handleBusyMessage(event, this, "followUp", builtInCommand.args);
+                const handled = await this.handler.handleBusyMessage(event, this, "followUp", builtInCommand.args);
+                if (!handled) {
+                    this.enqueueStreamMessage(event);
+                }
                 return;
             }
             if (builtInCommand) {
-                await this.sendPlain(channelId, "A task is already running. Use `/stop`, `/steer <message>`, or `/followup <message>`. Plain messages default to steer.");
+                await this.sendPlain(channelId, `A task is already running. Use \`/stop\`, \`/steer <message>\`, or \`/followup <message>\`. Plain messages default to ${this.busyMessageDefault}.`);
                 return;
             }
             if (isSlashCommand) {
                 await this.sendPlain(channelId, "A task is already running. Only `/stop`, `/steer <message>`, and `/followup <message>` are available while streaming.");
                 return;
             }
-            await this.handler.handleBusyMessage(event, this, "steer", content);
+            const handled = await this.handler.handleBusyMessage(event, this, this.busyMessageDefault, content);
+            if (!handled) {
+                this.enqueueStreamMessage(event);
+            }
             return;
         }
         // Enqueue for processing
-        this.getQueue(channelId).enqueue(async () => {
-            this.activeMessageProcessing = true;
-            try {
-                await this.handler.handleEvent(event, this);
-            }
-            finally {
-                this.activeMessageProcessing = false;
-                this.lastSocketAvailableTime = Date.now();
-            }
-        });
+        this.enqueueStreamMessage(event);
     }
     getQueue(channelId) {
         let queue = this.queues.get(channelId);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oyasmi/pipiclaw",
-	"version": "0.6.4",
+	"version": "0.6.6-beta.1",
 	"description": "An AI assistant runtime for coding and team workflows, with DingTalk AI Cards, sub-agents, memory, and scheduled events.",
 	"type": "module",
 	"bin": {