@love-moon/ai-sdk 0.7.6 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @love-moon/ai-sdk
 
+## 0.8.0
+
+## 0.7.7
+
 ## 0.7.6
 
 ### Patch Changes

package/dist/providers/codex-app-server-session.d.ts

@@ -139,6 +139,17 @@ export class CodexAppServerSession extends EventEmitter<[never]> {
         thread_id: any;
     };
     emitWorkingStatus(payload: any): Promise<void>;
+    /**
+     * Idempotent terminal working-status clear (see BUG-R6-01 lesson). The
+     * "reply_in_progress:false" signal that unsticks the composer must be emitted
+     * from a reliable, always-arriving path, and multiple paths emitting it must
+     * be a safe no-op. A one-time guard on the turn object ensures we clear
+     * exactly once regardless of how many code paths reach here.
+     */
+    emitTurnCompletedStatus(currentTurn: any, { phase, status_done_line }?: {
+        phase?: string | undefined;
+        status_done_line?: string | undefined;
+    }): Promise<void>;
     emitAssistantMessage(text: any): Promise<void>;
     finalizeActiveAssistantMessage(currentTurn?: {
         turnId: string;

package/dist/providers/codex-app-server-session.js

@@ -489,6 +489,26 @@ export class CodexAppServerSession extends EventEmitter {
         }
         this.emit("working_status", snapshot);
     }
+    /**
+     * Idempotent terminal working-status clear (see BUG-R6-01 lesson). The
+     * "reply_in_progress:false" signal that unsticks the composer must be emitted
+     * from a reliable, always-arriving path, and multiple paths emitting it must
+     * be a safe no-op. A one-time guard on the turn object ensures we clear
+     * exactly once regardless of how many code paths reach here.
+     */
+    async emitTurnCompletedStatus(currentTurn, { phase = "turn_completed", status_done_line = "codex finished" } = {}) {
+        if (currentTurn && currentTurn.terminalStatusEmitted) {
+            return;
+        }
+        if (currentTurn) {
+            currentTurn.terminalStatusEmitted = true;
+        }
+        await this.emitWorkingStatus({
+            phase,
+            reply_in_progress: false,
+            status_done_line,
+        });
+    }
     async emitAssistantMessage(text) {
         this.touchTurnActivity();
         const payload = {
@@ -869,7 +889,15 @@ export class CodexAppServerSession extends EventEmitter {
                 return;
             }
             case "turn/completed": {
-                const currentTurn = this.ensureCurrentTurn(params);
+                let currentTurn = this.ensureCurrentTurn(params);
+                if (!currentTurn && this.currentTurn && !this.currentTurn.goalMode) {
+                    // Defense-in-depth (BUG-R6-01 class): a non-goal session has exactly
+                    // one active turn. If turn matching fails (missing `turn/started`, a
+                    // turnId mismatch, or an id carried on a different field), we must NOT
+                    // strand the terminal clear here — otherwise the composer stays on
+                    // "codex composing reply" until the 12-min idle deadline or a reload.
+                    currentTurn = this.currentTurn;
+                }
                 if (!currentTurn) {
                     return;
                 }
@@ -887,9 +915,8 @@ export class CodexAppServerSession extends EventEmitter {
                         turnStatus: status,
                         turnError,
                     });
-                    await this.emitWorkingStatus({
+                    await this.emitTurnCompletedStatus(currentTurn, {
                         phase: "turn_failed",
-                        reply_in_progress: false,
                         status_done_line: `codex failed (${status})`,
                     });
                     if (currentTurn.goalMode) {
@@ -927,11 +954,7 @@ export class CodexAppServerSession extends EventEmitter {
                     currentTurn.activeAssistantMessageText = "";
                     return;
                 }
-                await this.emitWorkingStatus({
-                    phase: "turn_completed",
-                    reply_in_progress: false,
-                    status_done_line: "codex finished",
-                });
+                await this.emitTurnCompletedStatus(currentTurn);
                 currentTurn.resolve({
                     turn,
                     usage: this.tokenUsage ? { ...this.tokenUsage } : null,
@@ -1075,6 +1098,10 @@ export class CodexAppServerSession extends EventEmitter {
             await this.finalizeActiveAssistantMessage(currentTurn, {
                 messageId: currentTurn.activeAssistantMessageId,
             });
+            // Belt-and-suspenders terminal clear. Idempotent (guarded on the turn),
+            // so when the wire `turn/completed` already cleared this is a no-op; it
+            // only fires if the turn resolved without the wire clear reaching here.
+            await this.emitTurnCompletedStatus(currentTurn);
             if (currentTurn.fullText) {
                 this.history.push({ role: "assistant", content: currentTurn.fullText });
             }

package/dist/providers/kimi-cli-session.d.ts

@@ -22,6 +22,9 @@ export class KimiCliSession extends EventEmitter<[never]> {
     currentTurn: {
         fullText: string;
         bufferedAssistantText: string;
+        thinkText: string;
+        thinkStatusLine: string;
+        thinkStatusLineAt: number;
         items: never[];
         toolCalls: Map<any, any>;
         onProgress: null;
@@ -136,6 +139,8 @@ export class KimiCliSession extends EventEmitter<[never]> {
     bootInternal(): Promise<void>;
     updateUsageFromStatus(payload: any): void;
     appendAssistantText(currentTurn: any, text: any): void;
+    appendThinkText(currentTurn: any, text: any): void;
+    thinkStatusLine(currentTurn: any): any;
     finalizeAssistantMessage(currentTurn: any): Promise<boolean>;
     maybeEmitAuthRequired(error: any): void;
     failUnexpectedInteractiveRequest(id: any, requestType: any, payload: any): Promise<void>;

package/dist/providers/kimi-cli-session.js

@@ -11,6 +11,8 @@ const DEFAULT_STATUS_THROTTLE_MS = 450;
 const DEFAULT_REASONING_STATUS_THROTTLE_MS = 2500;
 const DEFAULT_STATUS_PREVIEW_DELTA_CHARS = 24;
 const MAX_STATUS_TIMING_MS = 10 * 1000;
+const THINK_STATUS_LINE_MAX_CHARS = 120;
+const THINK_TAIL_BUFFER_CHARS = 400;
 function waitForever() {
     return new Promise(() => { });
 }
@@ -603,6 +605,29 @@ export class KimiCliSession extends EventEmitter {
         }
         currentTurn.bufferedAssistantText += normalized;
     }
+    appendThinkText(currentTurn, text) {
+        const normalized = normalizeText(text);
+        if (!normalized) {
+            return;
+        }
+        currentTurn.thinkText = `${currentTurn.thinkText}${normalized}`.slice(-THINK_TAIL_BUFFER_CHARS);
+    }
+    thinkStatusLine(currentTurn) {
+        const now = this.now();
+        if (currentTurn.thinkStatusLine &&
+            now - currentTurn.thinkStatusLineAt < this.reasoningStatusThrottleMs) {
+            return currentTurn.thinkStatusLine;
+        }
+        const sanitized = sanitizeSummary(currentTurn.thinkText, THINK_TAIL_BUFFER_CHARS);
+        const snippet = sanitized.length > THINK_STATUS_LINE_MAX_CHARS
+            ? `…${sanitized.slice(-THINK_STATUS_LINE_MAX_CHARS)}`
+            : sanitized;
+        if (snippet && snippet !== currentTurn.thinkStatusLine) {
+            currentTurn.thinkStatusLine = snippet;
+            currentTurn.thinkStatusLineAt = now;
+        }
+        return currentTurn.thinkStatusLine || statusLineForPhase("reasoning");
+    }
     async finalizeAssistantMessage(currentTurn) {
         if (!currentTurn) {
             return false;
@@ -707,8 +732,23 @@ export class KimiCliSession extends EventEmitter {
                 return;
             case "TurnEnd":
                 currentTurn.seenTurnEnd = true;
+                if (currentTurn.bufferedAssistantText) {
+                    await this.finalizeAssistantMessage(currentTurn);
+                }
+                // Clear reply_in_progress as soon as the wire reports the turn ended,
+                // decoupled from the `prompt` JSON-RPC promise. Without this, a delayed
+                // or dropped prompt RPC response leaves the web UI pinned on
+                // "Kimi is writing the reply" until reload. emitTerminalWorkingStatus is
+                // idempotent, so the later runTurn call becomes a harmless no-op.
+                await this.emitTerminalWorkingStatus(currentTurn, {
+                    phase: "turn_completed",
+                    status_done_line: "Kimi finished",
+                }, currentTurn.onProgress);
                 return;
             case "StepBegin":
+                if (currentTurn.bufferedAssistantText) {
+                    await this.finalizeAssistantMessage(currentTurn);
+                }
                 await this.emitWorkingStatus({
                     phase: "reasoning",
                     reply_in_progress: true,
@@ -734,10 +774,11 @@ export class KimiCliSession extends EventEmitter {
                 return;
             case "ContentPart":
                 if (normalizedPayload.type === "think") {
+                    this.appendThinkText(currentTurn, normalizedPayload.think);
                     await this.emitWorkingStatus({
                         phase: "reasoning",
                         reply_in_progress: true,
-                        status_line: statusLineForPhase("reasoning"),
+                        status_line: this.thinkStatusLine(currentTurn),
                     }, currentTurn.onProgress);
                     return;
                 }
@@ -860,6 +901,9 @@ export class KimiCliSession extends EventEmitter {
         const currentTurn = {
             fullText: "",
             bufferedAssistantText: "",
+            thinkText: "",
+            thinkStatusLine: "",
+            thinkStatusLineAt: 0,
             items: [],
             toolCalls: new Map(),
             onProgress,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/ai-sdk",
-  "version": "0.7.6",
+  "version": "0.8.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -32,12 +32,12 @@
     "zod": "^4.1.5"
   },
   "optionalDependencies": {
-    "@love-moon/chat-web": "^0.7.6"
+    "@love-moon/chat-web": "^0.8.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
     "tsx": "^4.20.6",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "c939df2"
+  "gitCommitId": "04d4f62"
 }