@oyasmi/pipiclaw 0.6.5 → 0.6.6-beta.2

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

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

package/dist/agent/channel-runner.js

@@ -53,6 +53,8 @@ function asSdkSettingsManager(manager) {
 export class ChannelRunner {
     constructor(sandboxConfig, channelId, channelDir) {
         this.firstTurnMemoryBootstrapPending = true;
+        this.acceptingBusyMessages = false;
+        this.agentLoopStarted = false;
         // --- Per run ---
         this.runState = createEmptyRunState();
         this.sandboxConfig = sandboxConfig;
@@ -169,8 +171,11 @@ export class ChannelRunner {
     // === Public API ===
     async run(ctx, store) {
         this.resetRunState(ctx, store);
+        this.acceptingBusyMessages = true;
+        this.agentLoopStarted = false;
         const runQueue = createRunQueue(ctx);
         this.runState.queue = runQueue.queue;
+        let promptSubmitted = false;
         try {
             await this.ensureSessionReady();
             this.memoryLifecycle.noteUserTurnStarted();
@@ -225,6 +230,7 @@ export class ChannelRunner {
             }
             await this.sessionResourceGate.runPrompt(async () => {
                 await this.session.prompt(promptText);
+                promptSubmitted = true;
             });
         }
         catch (err) {
@@ -233,6 +239,15 @@ export class ChannelRunner {
             log.logWarning(`[${this.channelId}] Runner failed`, this.runState.errorMessage);
         }
         finally {
+            this.acceptingBusyMessages = false;
+            this.agentLoopStarted = 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 +438,37 @@ 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.");
+        }
+        if (this.agentLoopStarted && !this.session.isStreaming) {
             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.");
+        }
+        if (this.agentLoopStarted && !this.session.isStreaming) {
+            throw new Error("No task is currently running.");
+        }
+        const queueMessage = async () => {
+            if (this.agentLoopStarted && !this.session.isStreaming) {
+                throw new Error("No task is currently running.");
+            }
+            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();
@@ -564,6 +596,9 @@ export class ChannelRunner {
     // === Session event subscription ===
     subscribeToSessionEvents() {
         this.session.subscribe(async (event) => {
+            if (isRecord(event) && event.type === "message_start") {
+                this.agentLoopStarted = true;
+            }
             if (isRecord(event) && "reason" in event && event.reason === "new") {
                 this.firstTurnMemoryBootstrapPending = true;
             }

package/dist/agent/session-events.js

@@ -127,6 +127,7 @@ export async function handleSessionEvent(event, context) {
         const commandResultText = extractCustomCommandResultText(event.message);
         if (commandResultText) {
             runState.finalOutcome = { kind: "final", text: commandResultText };
+            runState.finalResponseDelivered = false;
             log.logResponse(logCtx, commandResultText);
             queue.enqueue(async () => {
                 const delivered = await ctx.respondPlain(commandResultText);
@@ -195,6 +196,7 @@ export async function handleSessionEvent(event, context) {
                 return;
             }
             runState.finalOutcome = { kind: "final", text: finalText };
+            runState.finalResponseDelivered = false;
             memoryLifecycle.noteCompletedAssistantTurn();
             log.logResponse(logCtx, finalText);
             queue.enqueue(async () => {

package/dist/runtime/bootstrap.js

@@ -341,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;
@@ -390,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);
@@ -411,6 +404,16 @@ 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"
                     ? event.text.trim().startsWith("/")
                         ? "Queued as follow-up. I’ll handle it after the current task completes."
@@ -420,11 +423,17 @@ export function createRuntimeContext(options) {
                         : "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

@@ -96,10 +96,28 @@ class ChannelDeliveryController {
             log.logWarning(`[${this.event.channelId}] Failed to archive bot response`, err instanceof Error ? err.message : String(err));
         });
     }
+    resetProgressAfterFinal() {
+        if (!this.finalResponseDelivered) {
+            return;
+        }
+        this.progressSegments = [];
+        this.cachedProgressText = "";
+        this.progressTextDirty = false;
+        this.mode = "progress";
+        this.progressStartedAt = 0;
+        this.progressWindowStartedAt = 0;
+        this.toolCallCount = 0;
+        this.sentProgressChars = 0;
+        this.replayRequired = false;
+        this.finalReplacementText = "";
+        this.cardWarmupTriggered = false;
+        this.finalResponseDelivered = false;
+    }
     async appendProgress(text, shouldLog) {
-        if (this.closed || this.finalResponseDelivered || !text.trim())
+        if (this.closed || !text.trim())
             return;
         this.clearCardWarmup();
+        this.resetProgressAfterFinal();
         if (this.progressStartedAt === 0) {
             this.progressStartedAt = Date.now();
         }
@@ -124,8 +142,8 @@ class ChannelDeliveryController {
         this.bumpRevision(false);
     }
     async sendFinal(text, shouldLog) {
-        if (this.closed || this.finalResponseDelivered)
-            return this.finalResponseDelivered;
+        if (this.closed)
+            return false;
         this.clearCardWarmup();
         if (shouldLog) {
             this.archiveBotResponse(text);
@@ -140,7 +158,7 @@ class ChannelDeliveryController {
         return true;
     }
     async replaceWithFinal(text) {
-        if (this.closed || this.finalResponseDelivered)
+        if (this.closed)
             return;
         this.clearCardWarmup();
         this.finalReplacementText = text;

package/dist/runtime/dingtalk.d.ts

@@ -51,7 +51,7 @@ 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;
@@ -105,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

@@ -481,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
     // ==========================================================================
@@ -858,11 +870,17 @@ 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) {
@@ -873,20 +891,14 @@ export class DingTalkBot {
                 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, this.busyMessageDefault, 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.5",
+	"version": "0.6.6-beta.2",
 	"description": "An AI assistant runtime for coding and team workflows, with DingTalk AI Cards, sub-agents, memory, and scheduled events.",
 	"type": "module",
 	"bin": {