@oyasmi/pipiclaw 0.6.6-beta.1 → 0.6.6-beta.3

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

@@ -25,6 +25,7 @@ export declare class ChannelRunner implements AgentRunner {
     private currentSkills;
     private firstTurnMemoryBootstrapPending;
     private acceptingBusyMessages;
+    private agentLoopStarted;
     private runState;
     constructor(sandboxConfig: SandboxConfig, channelId: string, channelDir: string);
     run(ctx: DingTalkContext, store: ChannelStore): Promise<{
@@ -33,7 +34,6 @@ export declare class ChannelRunner implements AgentRunner {
     }>;
     handleBuiltinCommand(ctx: DingTalkContext, command: BuiltInCommand): Promise<void>;
     queueSteer(text: string, userName?: string): Promise<void>;
-    queueFollowUp(text: string, userName?: string): Promise<void>;
     flushMemoryForShutdown(): Promise<void>;
     getMemoryMaintenanceContext(): Promise<MemoryMaintenanceRuntimeContext>;
     abort(): Promise<void>;

package/dist/agent/channel-runner.js

@@ -54,6 +54,7 @@ export class ChannelRunner {
     constructor(sandboxConfig, channelId, channelDir) {
         this.firstTurnMemoryBootstrapPending = true;
         this.acceptingBusyMessages = false;
+        this.agentLoopStarted = false;
         // --- Per run ---
         this.runState = createEmptyRunState();
         this.sandboxConfig = sandboxConfig;
@@ -171,6 +172,7 @@ export class ChannelRunner {
     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;
@@ -238,6 +240,7 @@ export class ChannelRunner {
         }
         finally {
             this.acceptingBusyMessages = false;
+            this.agentLoopStarted = false;
             if (!promptSubmitted) {
                 const discarded = this.session.clearQueue();
                 const discardedCount = discarded.steering.length + discarded.followUp.length;
@@ -353,10 +356,7 @@ export class ChannelRunner {
         }
     }
     async queueSteer(text, userName) {
-        await this.queueBusyMessage("steer", this.requireQueuedMessage(text, "steer"), userName);
-    }
-    async queueFollowUp(text, userName) {
-        await this.queueBusyMessage("followUp", this.requireQueuedMessage(text, "followup"), userName);
+        await this.queueBusyMessage(this.requireQueuedMessage(text, "steer"), userName);
     }
     async flushMemoryForShutdown() {
         await this.memoryLifecycle.flushForShutdown();
@@ -434,10 +434,13 @@ export class ChannelRunner {
         const timestamp = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}${offsetSign}${offsetHours}:${offsetMins}`;
         return `[${timestamp}] [${userName || "unknown"}]: ${text}`;
     }
-    async queueBusyMessage(delivery, text, userName) {
+    async queueBusyMessage(text, userName) {
         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()) {
@@ -448,13 +451,14 @@ export class ChannelRunner {
         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 (delivery === "followUp") {
-                await this.session.followUp(queuedMessage);
-            }
-            else {
-                await this.session.steer(queuedMessage);
+            if (this.agentLoopStarted && !this.session.isStreaming) {
+                throw new Error("No task is currently running.");
             }
+            await this.session.steer(queuedMessage);
         };
         await this.sessionResourceGate.runPrompt(queueMessage);
     }
@@ -584,6 +588,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/types.d.ts

@@ -10,7 +10,6 @@ export interface AgentRunner {
     }>;
     handleBuiltinCommand(ctx: DingTalkContext, command: BuiltInCommand): Promise<void>;
     queueSteer(text: string, userName?: string): Promise<void>;
-    queueFollowUp(text: string, userName?: string): Promise<void>;
     flushMemoryForShutdown(): Promise<void>;
     getMemoryMaintenanceContext(): Promise<MemoryMaintenanceRuntimeContext>;
     abort(): Promise<void>;

package/dist/runtime/bootstrap.js

@@ -393,17 +393,21 @@ export function createRuntimeContext(options) {
         },
         async handleBusyMessage(event, bot, mode, queueText) {
             if (shuttingDown) {
-                return true;
+                return { kind: "handled" };
             }
             const state = getState(event.channelId);
             const trimmedQueueText = queueText.trim();
+            if (!trimmedQueueText) {
+                const commandName = mode === "followUp" ? "followup" : "steer";
+                await bot.sendPlain(event.channelId, `Could not queue this message: /${commandName} requires a message.`);
+                return { kind: "handled" };
+            }
+            if (mode === "followUp") {
+                log.logInfo(`[${event.channelId}] Queued followUp as next task: ${trimmedQueueText.substring(0, 80)}`);
+                return { kind: "requeue", text: trimmedQueueText };
+            }
             try {
-                if (mode === "followUp") {
-                    await state.runner.queueFollowUp(trimmedQueueText, event.userName);
-                }
-                else {
-                    await state.runner.queueSteer(trimmedQueueText, event.userName);
-                }
+                await state.runner.queueSteer(trimmedQueueText, event.userName);
                 await archiveIncomingMessage(event.channelId, {
                     date: new Date().toISOString(),
                     ts: event.ts,
@@ -414,26 +418,22 @@ export function createRuntimeContext(options) {
                     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."
-                        : "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.";
+                const confirmation = 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;
+                return { kind: "handled" };
             }
             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;
+                    return { kind: "requeue", text: trimmedQueueText };
                 }
                 log.logWarning(`[${event.channelId}] Failed to queue ${mode}`, errMsg);
                 await bot.sendPlain(event.channelId, `Could not queue this message: ${errMsg}`);
-                return true;
+                return { kind: "handled" };
             }
         },
         async handleEvent(event, bot, _isEvent) {

package/dist/runtime/dingtalk.d.ts

@@ -47,11 +47,17 @@ export interface DingTalkContext {
     flush: () => Promise<void>;
     close: () => Promise<void>;
 }
+export type BusyMessageResult = {
+    kind: "handled";
+} | {
+    kind: "requeue";
+    text: string;
+};
 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<boolean>;
+    handleBusyMessage(event: DingTalkEvent, bot: DingTalkBot, mode: BusyMessageMode, queueText: string): Promise<BusyMessageResult>;
 }
 export declare class DingTalkBot {
     private handler;

package/dist/runtime/dingtalk.js

@@ -481,11 +481,12 @@ export class DingTalkBot {
         });
         return true;
     }
-    enqueueStreamMessage(event) {
+    enqueueStreamMessage(event, textOverride) {
+        const queuedEvent = textOverride === undefined ? event : { ...event, text: textOverride };
         this.getQueue(event.channelId).enqueue(async () => {
             this.activeMessageProcessing = true;
             try {
-                await this.handler.handleEvent(event, this);
+                await this.handler.handleEvent(queuedEvent, this);
             }
             finally {
                 this.activeMessageProcessing = false;
@@ -870,16 +871,16 @@ export class DingTalkBot {
                 return;
             }
             if (builtInCommand?.name === "steer") {
-                const handled = await this.handler.handleBusyMessage(event, this, "steer", builtInCommand.args);
-                if (!handled) {
-                    this.enqueueStreamMessage(event);
+                const result = await this.handler.handleBusyMessage(event, this, "steer", builtInCommand.args);
+                if (result.kind === "requeue") {
+                    this.enqueueStreamMessage(event, result.text);
                 }
                 return;
             }
             if (builtInCommand?.name === "followup") {
-                const handled = await this.handler.handleBusyMessage(event, this, "followUp", builtInCommand.args);
-                if (!handled) {
-                    this.enqueueStreamMessage(event);
+                const result = await this.handler.handleBusyMessage(event, this, "followUp", builtInCommand.args);
+                if (result.kind === "requeue") {
+                    this.enqueueStreamMessage(event, result.text);
                 }
                 return;
             }
@@ -891,9 +892,9 @@ export class DingTalkBot {
                 await this.sendPlain(channelId, "A task is already running. Only `/stop`, `/steer <message>`, and `/followup <message>` are available while streaming.");
                 return;
             }
-            const handled = await this.handler.handleBusyMessage(event, this, this.busyMessageDefault, content);
-            if (!handled) {
-                this.enqueueStreamMessage(event);
+            const result = await this.handler.handleBusyMessage(event, this, this.busyMessageDefault, content);
+            if (result.kind === "requeue") {
+                this.enqueueStreamMessage(event, result.text);
             }
             return;
         }

package/package.json

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