@love-moon/ai-sdk 0.13.3 → 0.14.0

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

@@ -60,7 +60,39 @@ function readTokenCount(breakdown) {
     const value = Number(breakdown?.totalTokens);
     return Number.isFinite(value) ? value : null;
 }
-/** Adds tokens spent outside the reported attempt (an overflowed first try) to a turn result or error. */
+/**
+ * The thread counters a turn's usage is a delta of; null when the total is
+ * unknown. A breakdown without the input split carries the total alone, so a
+ * build that omits it reports no cache share rather than a bogus one.
+ */
+function readTokenCounts(breakdown) {
+    const totalTokens = readTokenCount(breakdown);
+    if (totalTokens === null) {
+        return null;
+    }
+    const inputTokens = Number(breakdown.inputTokens);
+    const cachedInputTokens = Number(breakdown.cachedInputTokens);
+    return Number.isFinite(inputTokens) && Number.isFinite(cachedInputTokens)
+        ? { totalTokens, inputTokens, cachedInputTokens }
+        : { totalTokens };
+}
+function subtractTokenCounts(a, b) {
+    if (!a || !b) {
+        return null;
+    }
+    const split = a.inputTokens !== undefined && b.inputTokens !== undefined;
+    return {
+        totalTokens: a.totalTokens - b.totalTokens,
+        ...(split
+            ? { inputTokens: a.inputTokens - b.inputTokens, cachedInputTokens: a.cachedInputTokens - b.cachedInputTokens }
+            : {}),
+    };
+}
+/**
+ * Adds tokens spent outside the reported attempt (an overflowed first try) to a
+ * turn result or error. Only the total grows: the input split, and so the cache
+ * share, stays that of the attempt the fresh thread reported.
+ */
 function addTurnTokens(holder, extraTokens) {
     if (extraTokens > 0 && holder && typeof holder === "object") {
         const counted = Number(holder.usage?.turnTotalTokens);
@@ -204,6 +236,7 @@ export class CodexAppServerSession extends EventEmitter {
     static capabilities = Object.freeze({
         goal: true,
         compact: true,
+        clear: true,
         media: PROVIDER_MEDIA_CAPABILITIES[CODEX_APP_SERVER_VARIANT],
     });
     /**
@@ -217,6 +250,7 @@ export class CodexAppServerSession extends EventEmitter {
         this.backend = normalizeCodexBackend(backend);
         this.options = options;
         this.logger = normalizeLogger(options.logger);
+        this.traceReplyLatency = /^(1|true|yes)$/i.test(String(options.env?.CONDUCTOR_DEBUG ?? process.env.CONDUCTOR_DEBUG ?? ""));
         this.cwd =
             typeof options.cwd === "string" && options.cwd.trim()
                 ? options.cwd.trim()
@@ -414,8 +448,7 @@ export class CodexAppServerSession extends EventEmitter {
             this.bootPromise = null;
         }
     }
-    async bootInternal() {
-        await this.transport.boot();
+    buildThreadParams() {
         const params = {
             cwd: this.cwd,
             approvalPolicy: "never",
@@ -426,6 +459,11 @@ export class CodexAppServerSession extends EventEmitter {
         if (this.options.model) {
             params.model = this.options.model;
         }
+        return params;
+    }
+    async bootInternal() {
+        await this.transport.boot();
+        const params = this.buildThreadParams();
         let result;
         if (this.resumeSessionId) {
             result = await this.transport.request("thread/resume", {
@@ -492,24 +530,35 @@ export class CodexAppServerSession extends EventEmitter {
     }
     /** Start counting a turn's tokens from the thread total known right now. */
     beginTurnTokenAccounting() {
-        this.turnTokenBaseline = readTokenCount(this.tokenUsage?.total);
+        this.turnTokenBaseline = readTokenCounts(this.tokenUsage?.total);
         this.turnTokensSeen = false;
     }
     /**
-     * Thread token usage plus `turnTotalTokens`: tokens spent since the current
-     * turn (or goal) started. Codex only reports thread-cumulative totals, and
-     * only when a response completes, so a turn that ended before any response
-     * did has unknown usage.
+     * Thread token usage plus `turnTotalTokens` (and its `turnInputTokens` /
+     * `turnCachedInputTokens` split): tokens spent since the current turn (or
+     * goal) started. Codex only reports thread-cumulative totals, and only when
+     * a response completes, so a turn that ended before any response did has
+     * unknown usage.
      */
     snapshotTokenUsage() {
         if (!this.tokenUsage) {
             return null;
         }
-        const total = readTokenCount(this.tokenUsage.total);
+        const turn = this.turnTokensSeen
+            ? subtractTokenCounts(readTokenCounts(this.tokenUsage.total), this.turnTokenBaseline)
+            : null;
         return {
             ...this.tokenUsage,
-            ...(total !== null && this.turnTokenBaseline !== null && this.turnTokensSeen
-                ? { turnTotalTokens: Math.max(0, total - this.turnTokenBaseline) }
+            ...(turn
+                ? {
+                    turnTotalTokens: Math.max(0, turn.totalTokens),
+                    ...(turn.inputTokens !== undefined
+                        ? {
+                            turnInputTokens: Math.max(0, turn.inputTokens),
+                            turnCachedInputTokens: Math.max(0, turn.cachedInputTokens),
+                        }
+                        : {}),
+                }
                 : {}),
         };
     }
@@ -646,6 +695,8 @@ export class CodexAppServerSession extends EventEmitter {
             return false;
         }
         const text = currentTurn.activeAssistantMessageText || "";
+        const firstDeltaAt = currentTurn.activeAssistantFirstDeltaAt;
+        currentTurn.activeAssistantFirstDeltaAt = undefined;
         currentTurn.activeAssistantMessageText = "";
         if (!finalizedMessageId || !activeMessageId || activeMessageId === finalizedMessageId) {
             currentTurn.activeAssistantMessageId = "";
@@ -653,6 +704,13 @@ export class CodexAppServerSession extends EventEmitter {
         if (!text || currentTurn.suppressReply) {
             return false;
         }
+        if (this.traceReplyLatency && firstDeltaAt !== undefined) {
+            this.writeLog(`[codex-reply-latency] ${JSON.stringify({
+                event: "reply_emit", replyTo: this.getCurrentReplyTarget(),
+                turnId: currentTurn.turnId, itemId: finalizedMessageId,
+                firstDeltaToEmitMs: performance.now() - firstDeltaAt,
+            })}`);
+        }
         await this.emitAssistantMessage(text);
         return true;
     }
@@ -831,6 +889,17 @@ export class CodexAppServerSession extends EventEmitter {
         if (normalizedMessageId) {
             currentTurn.activeAssistantMessageId = normalizedMessageId;
         }
+        if (this.traceReplyLatency && delta && currentTurn.activeAssistantFirstDeltaAt === undefined) {
+            const firstDeltaAt = performance.now();
+            currentTurn.activeAssistantFirstDeltaAt = firstDeltaAt;
+            if (!currentTurn.suppressReply) {
+                this.writeLog(`[codex-reply-latency] ${JSON.stringify({
+                    event: "first_delta", replyTo: this.getCurrentReplyTarget(),
+                    turnId: currentTurn.turnId, itemId: normalizedMessageId,
+                    turnStartToDeltaMs: currentTurn.startedAt === undefined ? null : firstDeltaAt - currentTurn.startedAt,
+                })}`);
+            }
+        }
         currentTurn.fullText += delta;
         currentTurn.activeAssistantMessageText += delta;
     }
@@ -999,9 +1068,8 @@ export class CodexAppServerSession extends EventEmitter {
                         // No total was known when the turn started (fresh boot or resume):
                         // a replayed total is the baseline; this turn's first response
                         // has `total - last` before it.
-                        const total = readTokenCount(tokenUsage.total);
-                        const last = readTokenCount(tokenUsage.last);
-                        this.turnTokenBaseline = total === null ? null : beforeTurn ? total : last === null ? null : total - last;
+                        const total = readTokenCounts(tokenUsage.total);
+                        this.turnTokenBaseline = beforeTurn ? total : subtractTokenCounts(total, readTokenCounts(tokenUsage.last));
                     }
                     if (!beforeTurn) {
                         this.turnTokensSeen = true;
@@ -1202,6 +1270,7 @@ export class CodexAppServerSession extends EventEmitter {
                 reason: "turn_already_running",
             });
         }
+        const startedAt = performance.now();
         this.markTurnStartedStatus();
         try {
             await this.boot();
@@ -1220,6 +1289,7 @@ export class CodexAppServerSession extends EventEmitter {
             rejectTurn = reject;
         });
         const currentTurn = {
+            startedAt,
             turnId: "",
             fullText: "",
             activeAssistantMessageId: "",
@@ -1353,6 +1423,35 @@ export class CodexAppServerSession extends EventEmitter {
      * @param {import("../shared.js").CompactRequest} [request]
      * @returns {Promise<import("../shared.js").CompactResult>}
      */
+    /**
+     * Native clear: start a fresh thread on the SAME app-server connection. The
+     * process, transport and model config stay up; only the conversation is
+     * replaced, so the next turn runs against an empty thread.
+     */
+    async runClear() {
+        if (this.closeRequested) {
+            throw this.createSessionClosedError();
+        }
+        if (this.currentTurn || this.currentGoalRun) {
+            throw createTurnError("Codex app-server turn already running", {
+                reason: "turn_already_running",
+            });
+        }
+        if (this.pendingHistorySeed || (!this.resumeSessionId && !this.sessionId && this.history.length === 0)) {
+            return { clear: { status: "noop" }, usage: null, metadata: {} };
+        }
+        await this.boot();
+        const result = await this.transport.request("thread/start", this.buildThreadParams());
+        this.applyThreadInfo(result);
+        // A later re-boot must not resume the thread we just walked away from.
+        this.resumeSessionId = "";
+        this.history = [];
+        return {
+            clear: { status: "cleared", sessionId: this.sessionId || undefined },
+            usage: null,
+            metadata: {},
+        };
+    }
     async runCompact(request = {}) {
         if (this.closeRequested) {
             throw this.createSessionClosedError();

package/dist/providers/codex-exec-session.d.ts

@@ -53,6 +53,7 @@ export class CodexExecSession extends EventEmitter<[never]> {
         manualResume: null;
         currentTurnStatus: any;
         capabilities: {
+            clear: boolean;
             media: Readonly<{
                 image: "native";
             }>;
@@ -90,6 +91,19 @@ export class CodexExecSession extends EventEmitter<[never]> {
     emitWorkingStatus(payload: any, onProgress?: null): Promise<any>;
     emitAssistantMessage(text: any): Promise<void>;
     buildPrompt(promptText: any): string;
+    /**
+     * Native clear: `codex exec` is stateless — every turn replays this history
+     * as the prompt prefix (see buildPrompt), so dropping it IS the context
+     * clear. No process to restart, no session to rebind.
+     */
+    runClear(): Promise<{
+        clear: {
+            status: string;
+            sessionId: any;
+        };
+        usage: null;
+        metadata: {};
+    }>;
     buildExecArgs({ media, schemaFilePath, lastMessageFilePath }?: {
         media?: never[] | undefined;
         schemaFilePath?: string | undefined;

package/dist/providers/codex-exec-session.js

@@ -242,7 +242,7 @@ export class CodexExecSession extends EventEmitter {
             resumeReady: false,
             manualResume: null,
             currentTurnStatus: this.getCurrentTurnStatus(),
-            capabilities: { media: PROVIDER_MEDIA_CAPABILITIES[CODEX_EXEC_PROVIDER_VARIANT] },
+            capabilities: { clear: true, media: PROVIDER_MEDIA_CAPABILITIES[CODEX_EXEC_PROVIDER_VARIANT] },
             pid: this.currentTurn?.child?.pid || undefined,
         };
     }
@@ -342,6 +342,25 @@ export class CodexExecSession extends EventEmitter {
     buildPrompt(promptText) {
         return buildHistoryPrompt(this.history, promptText);
     }
+    /**
+     * Native clear: `codex exec` is stateless — every turn replays this history
+     * as the prompt prefix (see buildPrompt), so dropping it IS the context
+     * clear. No process to restart, no session to rebind.
+     */
+    async runClear() {
+        if (this.currentTurn) {
+            throw createTurnError("Codex exec turn already running", {
+                reason: "turn_already_running",
+            });
+        }
+        const hadContext = this.history.length > 0;
+        this.history = [];
+        return {
+            clear: { status: hadContext ? "cleared" : "noop", sessionId: this.sessionId || undefined },
+            usage: null,
+            metadata: {},
+        };
+    }
     buildExecArgs({ media = [], schemaFilePath = "", lastMessageFilePath = "" } = {}) {
         const args = [...this.baseArgs];
         args.push("exec");

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

@@ -85,6 +85,7 @@ export class CopilotSdkSession extends EventEmitter<[never]> {
         currentTurnStatus: any;
         capabilities: {
             compact: boolean;
+            clear: boolean;
             media: Readonly<{
                 image: "native";
             }>;
@@ -147,6 +148,26 @@ export class CopilotSdkSession extends EventEmitter<[never]> {
     getSdkModule(): Promise<any>;
     boot(): Promise<void>;
     bootInternal(): Promise<void>;
+    /**
+     * Native clear: create a new session on the SAME CopilotClient, so the CLI
+     * subprocess keeps running. The old conversation is left on disk (resumable)
+     * and we simply stop listening to it.
+     */
+    runClear(): Promise<{
+        clear: {
+            status: string;
+            sessionId?: undefined;
+        };
+        usage: null;
+        metadata: {};
+    } | {
+        clear: {
+            status: string;
+            sessionId: any;
+        };
+        usage: null;
+        metadata: {};
+    }>;
     attachSessionEventHandlers(session: any): void;
     detachSessionEventHandlers(): void;
     requestOrThrow(promise: any): Promise<any>;

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

@@ -505,6 +505,21 @@ function buildCopilotSessionConfig(options, cwd, permissionHandler) {
     }
     return sessionConfig;
 }
+function resolveCopilotPermissionHandler(sdkModule) {
+    return typeof sdkModule?.approveAll === "function"
+        ? sdkModule.approveAll
+        : () => ({ kind: "approve-once" });
+}
+function sessionInfoExtrasFromConfig(sessionConfig = {}) {
+    return {
+        model: typeof sessionConfig.model === "string" && sessionConfig.model.trim()
+            ? sessionConfig.model.trim()
+            : undefined,
+        reasoningEffort: typeof sessionConfig.reasoningEffort === "string" && sessionConfig.reasoningEffort.trim()
+            ? sessionConfig.reasoningEffort.trim()
+            : undefined,
+    };
+}
 export class CopilotSdkSession extends EventEmitter {
     constructor(backend, options = {}) {
         super();
@@ -594,7 +609,7 @@ export class CopilotSdkSession extends EventEmitter {
                 }
                 : null,
             currentTurnStatus: this.getCurrentTurnStatus(),
-            capabilities: { compact: true, media: PROVIDER_MEDIA_CAPABILITIES[COPILOT_PROVIDER_VARIANT] },
+            capabilities: { compact: true, clear: true, media: PROVIDER_MEDIA_CAPABILITIES[COPILOT_PROVIDER_VARIANT] },
         };
     }
     getSessionInfo() {
@@ -910,9 +925,7 @@ export class CopilotSdkSession extends EventEmitter {
         if (!sdkModule || typeof sdkModule.CopilotClient !== "function") {
             throw new Error("GitHub Copilot SDK client is unavailable");
         }
-        const permissionHandler = typeof sdkModule.approveAll === "function"
-            ? sdkModule.approveAll
-            : () => ({ kind: "approve-once" });
+        const permissionHandler = resolveCopilotPermissionHandler(sdkModule);
         const clientOptions = buildCopilotClientOptions(this.options, this.cwd, this.env);
         this.client = new sdkModule.CopilotClient(clientOptions);
         const cleanupIfClosedDuringBoot = async (session = null) => {
@@ -941,14 +954,44 @@ export class CopilotSdkSession extends EventEmitter {
             : await this.requestOrThrow(this.client.createSession(sessionConfig));
         await cleanupIfClosedDuringBoot(this.session);
         this.attachSessionEventHandlers(this.session);
-        this.applySessionInfo(this.session?.sessionId, {
-            model: typeof sessionConfig.model === "string" && sessionConfig.model.trim()
-                ? sessionConfig.model.trim()
-                : undefined,
-            reasoningEffort: typeof sessionConfig.reasoningEffort === "string" && sessionConfig.reasoningEffort.trim()
-                ? sessionConfig.reasoningEffort.trim()
-                : undefined,
-        });
+        this.applySessionInfo(this.session?.sessionId, sessionInfoExtrasFromConfig(sessionConfig));
+    }
+    /**
+     * Native clear: create a new session on the SAME CopilotClient, so the CLI
+     * subprocess keeps running. The old conversation is left on disk (resumable)
+     * and we simply stop listening to it.
+     */
+    async runClear() {
+        if (this.currentTurn) {
+            throw this.createTurnAlreadyRunningError();
+        }
+        if (this.pendingHistorySeed || (!this.session && !this.resumeSessionId && !this.sessionId)) {
+            return { clear: { status: "noop" }, usage: null, metadata: {} };
+        }
+        await this.boot();
+        const sdkModule = await this.getSdkModule();
+        const sessionConfig = buildCopilotSessionConfig(this.options, this.cwd, resolveCopilotPermissionHandler(sdkModule));
+        const previousSession = this.session;
+        const session = await this.requestOrThrow(this.client.createSession(sessionConfig));
+        this.session = session;
+        this.attachSessionEventHandlers(session);
+        this.applySessionInfo(session?.sessionId, sessionInfoExtrasFromConfig(sessionConfig));
+        // A later re-boot must not reattach to the conversation we walked away from.
+        this.resumeSessionId = "";
+        this.history = [];
+        if (previousSession && previousSession !== session && typeof previousSession.disconnect === "function") {
+            try {
+                await previousSession.disconnect();
+            }
+            catch {
+                // best effort: the old conversation is already detached from this session
+            }
+        }
+        return {
+            clear: { status: "cleared", sessionId: this.sessionId || undefined },
+            usage: null,
+            metadata: {},
+        };
     }
     attachSessionEventHandlers(session) {
         if (!session || typeof session.on !== "function") {

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

@@ -19,11 +19,13 @@ export class DshSdkSession extends EventEmitter<[never]> {
     static capabilities: Readonly<{
         goal: false;
         compact: true;
+        clear: true;
     }>;
     constructor(backend: any, options?: {});
     getCapabilities(): {
         goal: false;
         compact: true;
+        clear: true;
     };
     backend: string;
     options: {};
@@ -92,6 +94,7 @@ export class DshSdkSession extends EventEmitter<[never]> {
         capabilities: {
             goal: false;
             compact: true;
+            clear: true;
         };
     };
     getSessionInfo(): {
@@ -180,9 +183,56 @@ export class DshSdkSession extends EventEmitter<[never]> {
      * @param {{ onProgress?: Function }} [options]
      * @returns {Promise<import("../shared.js").CompactResult>}
      */
-    runCompact(request?: import("../shared.js").CompactRequest, { onProgress }?: {
-        onProgress?: Function;
-    }): Promise<import("../shared.js").CompactResult>;
+    /**
+     * Native clear: drop the conversation and rotate onto a fresh wire session id.
+     * The harness (and its runtime subprocess) stays up — the dsh runtime creates
+     * the new session lazily on its first prompt — so this costs no model call and
+     * no restart. Unlike runCompact there is nothing to carry over, so rotating
+     * here is safe: the new id has no persisted log, and resuming it restores an
+     * empty conversation, which is exactly what `/clear` promises.
+     */
+    runClear(): Promise<{
+        clear: {
+            status: string;
+            sessionId?: undefined;
+        };
+        usage: null;
+        metadata: {
+            source?: undefined;
+        };
+    } | {
+        clear: {
+            status: string;
+            sessionId: string;
+        };
+        usage: null;
+        metadata: {
+            source: string;
+        };
+    }>;
+    runCompact(request?: {}, { onProgress }?: {
+        onProgress?: null | undefined;
+    }): Promise<{
+        compact: {
+            status: string;
+            instructionsApplied: boolean;
+        };
+        usage: null;
+        metadata: {
+            source?: undefined;
+            sessionId?: undefined;
+        };
+    } | {
+        compact: {
+            status: string;
+            instructionsApplied: boolean;
+        };
+        usage: any;
+        metadata: {
+            source: string;
+            sessionId: string;
+        };
+    }>;
     runTurn(promptText: any, { useInitialImages, onProgress, suppressReply }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;

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

@@ -132,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, compact: true });
+    static capabilities = Object.freeze({ goal: false, compact: true, clear: true });
     getCapabilities() {
         return { ...DshSdkSession.capabilities };
     }
@@ -807,6 +807,29 @@ export class DshSdkSession extends EventEmitter {
      * @param {{ onProgress?: Function }} [options]
      * @returns {Promise<import("../shared.js").CompactResult>}
      */
+    /**
+     * Native clear: drop the conversation and rotate onto a fresh wire session id.
+     * The harness (and its runtime subprocess) stays up — the dsh runtime creates
+     * the new session lazily on its first prompt — so this costs no model call and
+     * no restart. Unlike runCompact there is nothing to carry over, so rotating
+     * here is safe: the new id has no persisted log, and resuming it restores an
+     * empty conversation, which is exactly what `/clear` promises.
+     */
+    async runClear() {
+        const resumableLog = this.pendingResumeFromSessionId && this.findPersistedSessionLog(this.pendingResumeFromSessionId);
+        if (this.history.length === 0 && !resumableLog) {
+            return { clear: { status: "noop" }, usage: null, metadata: {} };
+        }
+        this.history = [];
+        // Without this the next turn would restore the old session's log.
+        this.pendingResumeFromSessionId = "";
+        this.rotateSessionId();
+        return {
+            clear: { status: "cleared", sessionId: this.sessionId },
+            usage: null,
+            metadata: { source: DSH_SDK_VARIANT },
+        };
+    }
     async runCompact(request = {}, { onProgress = null } = {}) {
         const instructions = typeof request?.instructions === "string" ? request.instructions.trim() : "";
         const resumableLog = this.pendingResumeFromSessionId && this.findPersistedSessionLog(this.pendingResumeFromSessionId);

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

@@ -87,6 +87,7 @@ export class KimiCliSession extends EventEmitter<[never]> {
         currentTurnStatus: any;
         capabilities: {
             compact: boolean;
+            clear: boolean;
             media: Readonly<{
                 image: "native";
             }>;
@@ -169,6 +170,27 @@ export class KimiCliSession extends EventEmitter<[never]> {
     runCompact(request?: import("../shared.js").CompactRequest, { onProgress }?: {
         onProgress?: Function;
     }): Promise<import("../shared.js").CompactResult>;
+    /**
+     * Native `/clear`: the Kimi CLI answers the slash command locally (no model
+     * call) and keeps the same wire session, so only the context is dropped.
+     */
+    runClear(request?: {}, { onProgress }?: {
+        onProgress?: null | undefined;
+    }): Promise<{
+        clear: {
+            status: string;
+            sessionId?: undefined;
+        };
+        usage: null;
+        metadata: {};
+    } | {
+        clear: {
+            status: string;
+            sessionId: any;
+        };
+        usage: null;
+        metadata: any;
+    }>;
     runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress, jsonSchema, suppressReply }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;

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

@@ -5,6 +5,7 @@ import { appendContextFilesToPrompt } from "../context-files.js";
 import { PROVIDER_MEDIA_CAPABILITIES, buildKimiContent } from "../media-adapters.js";
 import { assertMediaCapabilities, defaultPromptForMedia, resolveTurnMedia, } from "../media-input.js";
 import { KimiWireTransport } from "../transports/kimi-wire-transport.js";
+import { assertKimiClearReply } from "./kimi-slash-commands.js";
 import { emitLog, getBoundedEnvInt, loadEnvConfig, normalizeLogger, noteToolFinished, noteToolStarted, proxyToEnv, sanitizeForLog, withActiveTool, } from "../shared.js";
 const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
 const MIN_TURN_DEADLINE_MS = 30 * 1000;
@@ -233,7 +234,7 @@ export class KimiCliSession extends EventEmitter {
                 }
                 : null,
             currentTurnStatus: this.getCurrentTurnStatus(),
-            capabilities: { compact: true, media: PROVIDER_MEDIA_CAPABILITIES[KIMI_PROVIDER_VARIANT] },
+            capabilities: { compact: true, clear: true, media: PROVIDER_MEDIA_CAPABILITIES[KIMI_PROVIDER_VARIANT] },
             pid: this.transport.pid || undefined,
         };
     }
@@ -905,6 +906,27 @@ export class KimiCliSession extends EventEmitter {
             metadata: turnResult.metadata,
         };
     }
+    /**
+     * Native `/clear`: the Kimi CLI answers the slash command locally (no model
+     * call) and keeps the same wire session, so only the context is dropped.
+     */
+    async runClear(request = {}, { onProgress = null } = {}) {
+        if (this.pendingHistorySeed) {
+            return { clear: { status: "noop" }, usage: null, metadata: {} };
+        }
+        const turnResult = await this.runTurn("/clear", { onProgress, suppressReply: true });
+        assertKimiClearReply(turnResult.text);
+        this.history = [];
+        // The previous turn's context reading describes a context that no longer
+        // exists; leave it unknown until kimi reports the next StatusUpdate.
+        this.lastContextUsagePercent = undefined;
+        return {
+            clear: { status: "cleared", sessionId: this.sessionId || undefined },
+            // A built-in slash command spends no tokens of its own.
+            usage: null,
+            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();

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

@@ -62,6 +62,7 @@ export class KimiPrintSession extends EventEmitter<[never]> {
         currentTurnStatus: any;
         capabilities: {
             compact: boolean;
+            clear: boolean;
             media: Readonly<{
                 image: "unsupported";
             }> | Readonly<{
@@ -129,6 +130,18 @@ export class KimiPrintSession extends EventEmitter<[never]> {
     runCompact(request?: import("../shared.js").CompactRequest, { onProgress }?: {
         onProgress?: Function;
     }): Promise<import("../shared.js").CompactResult>;
+    /**
+     * Native `/clear`: kimi-cli's built-in slash command, answered locally without
+     * a model call. Print mode spawns a child per turn, so nothing is torn down;
+     * the `--session` id stays the same and only its context file rotates.
+     *
+     * @param {Record<string, unknown>} [request]
+     * @param {{ onProgress?: Function }} [options]
+     * @returns {Promise<import("../shared.js").ClearResult>}
+     */
+    runClear(request?: Record<string, unknown>, { onProgress }?: {
+        onProgress?: Function;
+    }): Promise<import("../shared.js").ClearResult>;
     runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress, jsonSchema, suppressReply }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;