@love-moon/ai-sdk 0.13.1 → 0.13.3

package/dist/providers/dsh-sdk-session.js

@@ -11,6 +11,12 @@ const require = createRequire(import.meta.url);
 const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
 const MIN_TURN_DEADLINE_MS = 30 * 1000;
 const MAX_TURN_DEADLINE_MS = 30 * 60 * 1000;
+export const COMPACT_SUMMARY_PROMPT = [
+    "Summarize our conversation so far so it can replace the full history.",
+    "Keep the goals, decisions, current state of the work, relevant files and commands, and open next steps.",
+    "Do not use tools. Reply with the summary only.",
+].join(" ");
+const COMPACT_SUMMARY_PREFIX = "Summary of the conversation so far:\n\n";
 // Pinned defaults for the dsh runtime route. `deepseek-official` is the
 // provider route the stock `@deepseek-ai/dsh-llm-deepseek` adapter registers;
 // the model can be overridden via options.model or an allow_cli_list command
@@ -126,7 +132,7 @@ function accumulateUsage(total, usage) {
  * the next runTurn spawns a fresh runtime resuming the same session id.
  */
 export class DshSdkSession extends EventEmitter {
-    static capabilities = Object.freeze({ goal: false });
+    static capabilities = Object.freeze({ goal: false, compact: true });
     getCapabilities() {
         return { ...DshSdkSession.capabilities };
     }
@@ -376,6 +382,7 @@ export class DshSdkSession extends EventEmitter {
             return [];
         }
         const restored = [];
+        let compactSummaryPending = false;
         let content;
         try {
             content = fs.readFileSync(logPath, "utf8");
@@ -397,14 +404,26 @@ export class DshSdkSession extends EventEmitter {
             }
             if (event?.type === "user/message" && event.data?.source?.kind === "user") {
                 const text = extractTextBlocks(event.data?.content);
-                if (text) {
+                // A `/compact` summary turn supersedes everything before it, but only
+                // once its reply lands; a failed or interrupted one changes nothing.
+                compactSummaryPending = text.includes(COMPACT_SUMMARY_PROMPT);
+                if (text && !compactSummaryPending) {
                     restored.push({ role: "user", content: text });
                 }
                 continue;
             }
+            if (event?.type === "turn/end" && event.data?.reason?.kind !== "completed") {
+                compactSummaryPending = false;
+                continue;
+            }
             if (event?.type === "assistant/message") {
                 const text = extractTextBlocks(event.data?.message?.content);
-                if (text) {
+                if (text && compactSummaryPending) {
+                    restored.length = 0;
+                    restored.push({ role: "assistant", content: `${COMPACT_SUMMARY_PREFIX}${text}` });
+                    compactSummaryPending = false;
+                }
+                else if (text) {
                     restored.push({ role: "assistant", content: text });
                 }
             }
@@ -701,8 +720,11 @@ export class DshSdkSession extends EventEmitter {
                 if (!text) {
                     return;
                 }
-                currentTurn.emittedAssistantMessage = true;
                 currentTurn.fullText = text;
+                if (currentTurn.suppressReply) {
+                    return;
+                }
+                currentTurn.emittedAssistantMessage = true;
                 await this.emitWorkingStatus({
                     phase: "message_aggregation",
                     reply_in_progress: true,
@@ -745,6 +767,15 @@ export class DshSdkSession extends EventEmitter {
                 }, onProgress);
                 return;
             }
+            case "compaction/end": {
+                // Automatic compaction finished mid-turn; drop the "compacting" line.
+                await this.emitWorkingStatus({
+                    phase: "turn_started",
+                    reply_in_progress: true,
+                    status_line: "dsh is working",
+                }, onProgress);
+                return;
+            }
             case "turn/end": {
                 currentTurn.turnEndReason = event.data?.reason || null;
                 return;
@@ -766,7 +797,40 @@ export class DshSdkSession extends EventEmitter {
         await this.disposeHarness();
         return true;
     }
-    async runTurn(promptText, { useInitialImages = false, onProgress = null } = {}) {
+    /**
+     * Manually compact the conversation. The dsh SDK wire exposes no compaction
+     * request (its engine's `compactNow` is internal), so the model summarizes
+     * the conversation in one silent turn and the chat continues on a fresh
+     * wire session seeded with only that summary.
+     *
+     * @param {import("../shared.js").CompactRequest} [request]
+     * @param {{ onProgress?: Function }} [options]
+     * @returns {Promise<import("../shared.js").CompactResult>}
+     */
+    async runCompact(request = {}, { onProgress = null } = {}) {
+        const instructions = typeof request?.instructions === "string" ? request.instructions.trim() : "";
+        const resumableLog = this.pendingResumeFromSessionId && this.findPersistedSessionLog(this.pendingResumeFromSessionId);
+        if (this.history.length === 0 && !resumableLog) {
+            return { compact: { status: "noop", instructionsApplied: false }, usage: null, metadata: {} };
+        }
+        const prompt = instructions ? `${COMPACT_SUMMARY_PROMPT}\n\nAdditional focus: ${instructions}` : COMPACT_SUMMARY_PROMPT;
+        const turnResult = await this.runTurn(prompt, { onProgress, suppressReply: true });
+        const summary = String(turnResult.text || "").trim();
+        if (!summary) {
+            throw createTurnError("dsh compaction produced an empty summary", { reason: "compact_failed" });
+        }
+        this.history = [{ role: "assistant", content: `${COMPACT_SUMMARY_PREFIX}${summary}` }];
+        // Dropping the runtime makes the next turn rotate onto a fresh id seeded
+        // with the summary. Rotating here instead would expose the new id for
+        // binding before it has a persisted log, so a restart would resume empty.
+        await this.disposeHarness();
+        return {
+            compact: { status: "compacted", instructionsApplied: Boolean(instructions) },
+            usage: turnResult.usage,
+            metadata: { source: DSH_SDK_VARIANT, sessionId: this.sessionId },
+        };
+    }
+    async runTurn(promptText, { useInitialImages = false, onProgress = null, suppressReply = false } = {}) {
         if (this.closeRequested) {
             throw this.createSessionClosedError();
         }
@@ -798,8 +862,11 @@ export class DshSdkSession extends EventEmitter {
             this.rotateSessionId();
         }
         const effectivePrompt = this.buildPrompt(promptText, { useInitialImages });
-        this.history.push({ role: "user", content: promptText });
+        if (!suppressReply) {
+            this.history.push({ role: "user", content: promptText });
+        }
         const currentTurn = {
+            suppressReply,
             emittedAssistantMessage: false,
             fullText: "",
             interrupted: false,
@@ -861,10 +928,10 @@ export class DshSdkSession extends EventEmitter {
             const responseText = typeof runResult?.finalResponse === "string" && runResult.finalResponse
                 ? runResult.finalResponse
                 : currentTurn.fullText;
-            if (!currentTurn.emittedAssistantMessage && responseText) {
+            if (!suppressReply && !currentTurn.emittedAssistantMessage && responseText) {
                 await this.emitAssistantMessage(responseText);
             }
-            if (responseText) {
+            if (!suppressReply && responseText) {
                 this.history.push({ role: "assistant", content: responseText });
             }
             const turnEndKind = currentTurn.turnEndReason?.kind;

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

@@ -20,6 +20,8 @@ export class KimiCliSession extends EventEmitter<[never]> {
     activeReplyTarget: string;
     lastReplyTarget: string;
     currentTurn: {
+        suppressReply: boolean;
+        compacted: boolean;
         fullText: string;
         bufferedAssistantText: string;
         thinkText: string;
@@ -84,6 +86,7 @@ export class KimiCliSession extends EventEmitter<[never]> {
         } | null;
         currentTurnStatus: any;
         capabilities: {
+            compact: boolean;
             media: Readonly<{
                 image: "native";
             }>;
@@ -154,10 +157,23 @@ export class KimiCliSession extends EventEmitter<[never]> {
     handleTransportFailure(error: any): void;
     handleTransportExit(payload: any): void;
     interruptCurrentTurn(): Promise<boolean>;
-    runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress, jsonSchema }?: {
+    /**
+     * Manually compact via Kimi CLI's built-in `/compact` slash command, which
+     * the wire `prompt` method dispatches like the interactive shell does. The
+     * command takes no focus instructions.
+     *
+     * @param {import("../shared.js").CompactRequest} [request]
+     * @param {{ onProgress?: Function }} [options]
+     * @returns {Promise<import("../shared.js").CompactResult>}
+     */
+    runCompact(request?: import("../shared.js").CompactRequest, { onProgress }?: {
+        onProgress?: Function;
+    }): Promise<import("../shared.js").CompactResult>;
+    runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress, jsonSchema, suppressReply }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;
         jsonSchema?: null | undefined;
+        suppressReply?: boolean | undefined;
     }): Promise<{
         text: string;
         usage: null;
@@ -175,6 +191,7 @@ export class KimiCliSession extends EventEmitter<[never]> {
             promptStatus: string | undefined;
             contextUsagePercent: number | undefined;
         };
+        compacted: boolean;
     }>;
     close(): Promise<void>;
 }

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

@@ -233,7 +233,7 @@ export class KimiCliSession extends EventEmitter {
                 }
                 : null,
             currentTurnStatus: this.getCurrentTurnStatus(),
-            capabilities: { media: PROVIDER_MEDIA_CAPABILITIES[KIMI_PROVIDER_VARIANT] },
+            capabilities: { compact: true, media: PROVIDER_MEDIA_CAPABILITIES[KIMI_PROVIDER_VARIANT] },
             pid: this.transport.pid || undefined,
         };
     }
@@ -642,6 +642,9 @@ export class KimiCliSession extends EventEmitter {
         }
         currentTurn.fullText += text;
         currentTurn.bufferedAssistantText = "";
+        if (currentTurn.suppressReply) {
+            return false;
+        }
         await this.emitAssistantMessage(text);
         return true;
     }
@@ -760,6 +763,7 @@ export class KimiCliSession extends EventEmitter {
                 }, currentTurn.onProgress);
                 return;
             case "CompactionBegin":
+                currentTurn.compacted = true;
                 await this.emitWorkingStatus({
                     phase: "context_compaction",
                     reply_in_progress: true,
@@ -792,7 +796,9 @@ export class KimiCliSession extends EventEmitter {
                         phase: "message_aggregation",
                         reply_in_progress: true,
                         status_line: statusLineForPhase("message_aggregation"),
-                        reply_preview: sanitizeSummary(currentTurn.bufferedAssistantText, 120),
+                        reply_preview: currentTurn.suppressReply
+                            ? undefined
+                            : sanitizeSummary(currentTurn.bufferedAssistantText, 120),
                     }, currentTurn.onProgress);
                 }
                 return;
@@ -879,7 +885,27 @@ export class KimiCliSession extends EventEmitter {
         }
         return false;
     }
-    async runTurn(promptText, { useInitialImages = false, media: mediaInput, contextFiles, onProgress = null, jsonSchema = null } = {}) {
+    /**
+     * Manually compact via Kimi CLI's built-in `/compact` slash command, which
+     * the wire `prompt` method dispatches like the interactive shell does. The
+     * command takes no focus instructions.
+     *
+     * @param {import("../shared.js").CompactRequest} [request]
+     * @param {{ onProgress?: Function }} [options]
+     * @returns {Promise<import("../shared.js").CompactResult>}
+     */
+    async runCompact(request = {}, { onProgress = null } = {}) {
+        if (this.pendingHistorySeed) {
+            return { compact: { status: "noop", instructionsApplied: false }, usage: null, metadata: {} };
+        }
+        const turnResult = await this.runTurn("/compact", { onProgress, suppressReply: true });
+        return {
+            compact: { status: turnResult.compacted ? "compacted" : "noop", instructionsApplied: false },
+            usage: turnResult.usage,
+            metadata: turnResult.metadata,
+        };
+    }
+    async runTurn(promptText, { useInitialImages = false, media: mediaInput, contextFiles, onProgress = null, jsonSchema = null, suppressReply = false } = {}) {
         if (this.closeRequested || this.closed) {
             throw this.createSessionClosedError();
         }
@@ -907,8 +933,12 @@ export class KimiCliSession extends EventEmitter {
             await this.failPendingTurnStart(error, onProgress);
             throw error;
         }
-        this.history.push({ role: "user", content: promptText });
+        if (!suppressReply) {
+            this.history.push({ role: "user", content: promptText });
+        }
         const currentTurn = {
+            suppressReply,
+            compacted: false,
             fullText: "",
             bufferedAssistantText: "",
             thinkText: "",
@@ -950,7 +980,7 @@ export class KimiCliSession extends EventEmitter {
             ]);
             currentTurn.settled = true;
             await this.finalizeAssistantMessage(currentTurn);
-            if (currentTurn.fullText) {
+            if (currentTurn.fullText && !suppressReply) {
                 this.history.push({ role: "assistant", content: currentTurn.fullText });
             }
             const normalizedStatus = normalizeText(promptResult?.status);
@@ -979,6 +1009,7 @@ export class KimiCliSession extends EventEmitter {
                     promptStatus: normalizedStatus || undefined,
                     contextUsagePercent: this.lastContextUsagePercent,
                 },
+                compacted: currentTurn.compacted,
             };
         }
         catch (error) {

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

@@ -61,6 +61,7 @@ export class KimiPrintSession extends EventEmitter<[never]> {
         } | null;
         currentTurnStatus: any;
         capabilities: {
+            compact: boolean;
             media: Readonly<{
                 image: "unsupported";
             }> | Readonly<{
@@ -115,10 +116,24 @@ export class KimiPrintSession extends EventEmitter<[never]> {
     };
     maybeEmitAuthRequired(stderrTail: any): void;
     interruptCurrentTurn(): Promise<boolean>;
-    runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress, jsonSchema }?: {
+    /**
+     * Manually compact via kimi-cli's built-in `/compact` slash command; print
+     * mode runs it through the same soul as the interactive shell. Print output
+     * carries no compaction events, so the outcome is read from the CLI's fixed
+     * replies. The command takes no focus instructions.
+     *
+     * @param {import("../shared.js").CompactRequest} [request]
+     * @param {{ onProgress?: Function }} [options]
+     * @returns {Promise<import("../shared.js").CompactResult>}
+     */
+    runCompact(request?: import("../shared.js").CompactRequest, { onProgress }?: {
+        onProgress?: Function;
+    }): Promise<import("../shared.js").CompactResult>;
+    runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress, jsonSchema, suppressReply }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;
         jsonSchema?: null | undefined;
+        suppressReply?: boolean | undefined;
     }): Promise<{
         text: string;
         usage: null;

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

@@ -270,6 +270,8 @@ export class KimiPrintSession extends EventEmitter {
                 : null,
             currentTurnStatus: this.getCurrentTurnStatus(),
             capabilities: {
+                // Kimi Code's `--prompt` CLI is unverified for slash commands.
+                compact: this.cliMode !== "prompt",
                 media: this.cliMode === "prompt"
                     ? UNSUPPORTED_MEDIA_CAPABILITIES
                     : PROVIDER_MEDIA_CAPABILITIES[KIMI_PRINT_PROVIDER_VARIANT],
@@ -468,7 +470,42 @@ export class KimiPrintSession extends EventEmitter {
             return false;
         }
     }
-    async runTurn(promptText, { useInitialImages = false, media: mediaInput, contextFiles, onProgress = null, jsonSchema = null } = {}) {
+    /**
+     * Manually compact via kimi-cli's built-in `/compact` slash command; print
+     * mode runs it through the same soul as the interactive shell. Print output
+     * carries no compaction events, so the outcome is read from the CLI's fixed
+     * replies. The command takes no focus instructions.
+     *
+     * @param {import("../shared.js").CompactRequest} [request]
+     * @param {{ onProgress?: Function }} [options]
+     * @returns {Promise<import("../shared.js").CompactResult>}
+     */
+    async runCompact(request = {}, { onProgress = null } = {}) {
+        if (this.cliMode === "prompt") {
+            throw createTurnError("Kimi prompt mode does not support /compact", { reason: "unsupported_compact" });
+        }
+        if (this.pendingHistorySeed) {
+            return { compact: { status: "noop", instructionsApplied: false }, usage: null, metadata: {} };
+        }
+        const turnResult = await this.runTurn("/compact", { onProgress, suppressReply: true });
+        const reply = String(turnResult.text || "");
+        // Print mode exits 0 even when the model call fails, so only kimi-cli's
+        // fixed replies are trusted.
+        if (!/context has been compacted|context is empty/i.test(reply)) {
+            throw createTurnError(`Kimi compaction failed${reply.trim() ? `: ${reply.trim()}` : ""}`, {
+                reason: "compact_failed",
+            });
+        }
+        return {
+            compact: {
+                status: /context is empty/i.test(reply) ? "noop" : "compacted",
+                instructionsApplied: false,
+            },
+            usage: turnResult.usage,
+            metadata: turnResult.metadata,
+        };
+    }
+    async runTurn(promptText, { useInitialImages = false, media: mediaInput, contextFiles, onProgress = null, jsonSchema = null, suppressReply = false } = {}) {
         if (this.closeRequested || this.closed) {
             throw this.createSessionClosedError();
         }
@@ -497,7 +534,9 @@ export class KimiPrintSession extends EventEmitter {
             return buildEmptyTurnResult();
         }
         this.announceSession();
-        this.history.push({ role: "user", content: String(promptText || "") });
+        if (!suppressReply) {
+            this.history.push({ role: "user", content: String(promptText || "") });
+        }
         const currentTurn = {
             child: null,
             fullText: "",
@@ -624,7 +663,9 @@ export class KimiPrintSession extends EventEmitter {
                         }
                         if (assistantText) {
                             currentTurn.fullText += assistantText;
-                            void this.emitAssistantMessage(assistantText);
+                            if (!suppressReply) {
+                                void this.emitAssistantMessage(assistantText);
+                            }
                         }
                         return;
                     }
@@ -688,7 +729,7 @@ export class KimiPrintSession extends EventEmitter {
                 }
                 child.stdin.end();
             });
-            if (result?.text) {
+            if (result?.text && !suppressReply) {
                 this.history.push({ role: "assistant", content: result.text });
             }
             this.activeReplyTarget = "";

package/dist/providers/opencode-sdk-session.d.ts

@@ -20,7 +20,7 @@ export class OpencodeSdkSession extends EventEmitter<[never]> {
     activeReplyTarget: string;
     lastReplyTarget: string;
     currentTurn: {
-        abortController: AbortController;
+        abortController: any;
         assistantMessages: Map<any, any>;
         assistantMessageOrder: never[];
         activeAssistantMessageId: string;
@@ -29,7 +29,7 @@ export class OpencodeSdkSession extends EventEmitter<[never]> {
         fullText: string;
         items: never[];
         lastAssistantInfo: null;
-        onProgress: null;
+        onProgress: any;
         resolve: null;
         reject: null;
         settled: boolean;
@@ -79,6 +79,7 @@ export class OpencodeSdkSession extends EventEmitter<[never]> {
         manualResume: null;
         currentTurnStatus: any;
         capabilities: {
+            compact: boolean;
             media: Readonly<{
                 image: "native";
             }>;
@@ -169,6 +170,47 @@ export class OpencodeSdkSession extends EventEmitter<[never]> {
     handleTransportFailure(error: any): void;
     handleTransportExit(payload: any): void;
     interruptCurrentTurn(): Promise<boolean>;
+    createTurnState(abortController: any, onProgress: any): {
+        currentTurn: {
+            abortController: any;
+            assistantMessages: Map<any, any>;
+            assistantMessageOrder: never[];
+            activeAssistantMessageId: string;
+            messageRoles: Map<any, any>;
+            pendingMessageEvents: Map<any, any>;
+            fullText: string;
+            items: never[];
+            lastAssistantInfo: null;
+            onProgress: any;
+            resolve: null;
+            reject: null;
+            settled: boolean;
+            terminalWorkingStatusEmitted: boolean;
+        };
+        completionPromise: Promise<any>;
+    };
+    /**
+     * Model to summarize with: `session.summarize` requires one explicitly.
+     * Prefer what the session actually ran on (last turn, then its recent
+     * messages); the configured model is only a fallback.
+     */
+    resolveCompactionModel(): Promise<{
+        providerID: any;
+        modelID: any;
+    }>;
+    /**
+     * Manually compact via the server's `session.summarize` (what the TUI's
+     * `/compact` calls). It takes no focus instructions and answers `true`
+     * even when summarizing fails, so success is judged from the summary
+     * message itself.
+     *
+     * @param {import("../shared.js").CompactRequest} [request]
+     * @param {{ onProgress?: Function }} [options]
+     * @returns {Promise<import("../shared.js").CompactResult>}
+     */
+    runCompact(request?: import("../shared.js").CompactRequest, { onProgress }?: {
+        onProgress?: Function;
+    }): Promise<import("../shared.js").CompactResult>;
     runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress, jsonSchema }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;