@love-moon/ai-sdk 0.13.3 → 0.14.0

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

@@ -6,6 +6,7 @@ import { EventEmitter } from "node:events";
 import readline from "node:readline";
 import { KIMI_CLI_PRINT_VARIANT as KIMI_PRINT_PROVIDER_VARIANT } from "../built-in-backends.js";
 import { appendContextFilesToPrompt } from "../context-files.js";
+import { assertKimiClearReply } from "./kimi-slash-commands.js";
 import { PROVIDER_MEDIA_CAPABILITIES, UNSUPPORTED_MEDIA_CAPABILITIES, buildKimiContent, } from "../media-adapters.js";
 import { assertMediaCapabilities, defaultPromptForMedia, resolveTurnMedia, } from "../media-input.js";
 import { emitLog, getBoundedEnvInt, loadEnvConfig, normalizeLogger, noteToolFinished, noteToolStarted, parseCommandParts, proxyToEnv, sanitizeForLog, withActiveTool, } from "../shared.js";
@@ -272,6 +273,7 @@ export class KimiPrintSession extends EventEmitter {
             capabilities: {
                 // Kimi Code's `--prompt` CLI is unverified for slash commands.
                 compact: this.cliMode !== "prompt",
+                clear: this.cliMode !== "prompt",
                 media: this.cliMode === "prompt"
                     ? UNSUPPORTED_MEDIA_CAPABILITIES
                     : PROVIDER_MEDIA_CAPABILITIES[KIMI_PRINT_PROVIDER_VARIANT],
@@ -505,6 +507,33 @@ export class KimiPrintSession extends EventEmitter {
             metadata: turnResult.metadata,
         };
     }
+    /**
+     * 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>}
+     */
+    async runClear(request = {}, { onProgress = null } = {}) {
+        if (this.cliMode === "prompt") {
+            throw createTurnError("Kimi prompt mode does not support /clear", { reason: "unsupported_clear" });
+        }
+        if (this.pendingHistorySeed) {
+            return { clear: { status: "noop" }, usage: null, metadata: {} };
+        }
+        const turnResult = await this.runTurn("/clear", { onProgress, suppressReply: true });
+        // Print mode exits 0 even when the model call fails, so only kimi-cli's
+        // fixed reply is trusted.
+        assertKimiClearReply(turnResult.text);
+        this.history = [];
+        return {
+            clear: { status: "cleared", sessionId: this.sessionId || undefined },
+            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();

package/dist/providers/kimi-slash-commands.d.ts

@@ -0,0 +1 @@
+export function assertKimiClearReply(reply: any): void;

package/dist/providers/kimi-slash-commands.js

@@ -0,0 +1,23 @@
+/**
+ * kimi-cli answers `/clear` itself, without calling the model, with a fixed
+ * line (see kimi_cli/soul/slash.py). Both kimi modes verify that line before
+ * reporting success: if a kimi version ever stops treating `/clear` as a
+ * built-in, the text reaches the model as an ordinary turn — which grows the
+ * context instead of clearing it — and we must fail loudly rather than tell the
+ * user their context is gone.
+ *
+ * Kept in one place so the two modes cannot drift apart, in either direction.
+ */
+const KIMI_CLEAR_ACK = /context has been cleared/i;
+function createClearFailedError(message) {
+    const error = new Error(message);
+    error.reason = "clear_failed";
+    return error;
+}
+export function assertKimiClearReply(reply) {
+    const text = String(reply || "");
+    if (KIMI_CLEAR_ACK.test(text)) {
+        return;
+    }
+    throw createClearFailedError(`Kimi clear failed${text.trim() ? `: ${text.trim()}` : ""}`);
+}

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

@@ -80,6 +80,7 @@ export class OpencodeSdkSession extends EventEmitter<[never]> {
         currentTurnStatus: any;
         capabilities: {
             compact: boolean;
+            clear: boolean;
             media: Readonly<{
                 image: "native";
             }>;
@@ -208,9 +209,57 @@ export class OpencodeSdkSession 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: create a new session on the SAME opencode server (the server
+     * process and its event stream stay up); the old session is left untouched on
+     * disk, exactly like the boot path's `session.create`.
+     */
+    runClear(): Promise<{
+        clear: {
+            status: string;
+            sessionId?: undefined;
+        };
+        usage: null;
+        metadata: {};
+    } | {
+        clear: {
+            status: string;
+            sessionId: any;
+        };
+        usage: null;
+        metadata: {};
+    }>;
+    runCompact(request?: {}, { onProgress }?: {
+        onProgress?: null | undefined;
+    }): Promise<{
+        compact: {
+            status: string;
+            instructionsApplied: boolean;
+        };
+        usage: null;
+        metadata: {};
+    } | {
+        compact: {
+            status: string;
+            instructionsApplied: boolean;
+        };
+        usage: {
+            total: number | undefined;
+            input: number | undefined;
+            output: number | undefined;
+            reasoning: number | undefined;
+            cache: {
+                read: number | undefined;
+                write: number | undefined;
+            };
+        } | null;
+        metadata: {
+            providerID: any;
+            modelID: any;
+            source: string;
+            sessionId: any;
+        };
+    }>;
     runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress, jsonSchema }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;

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

@@ -231,7 +231,7 @@ export class OpencodeSdkSession extends EventEmitter {
             resumeReady: Boolean(this.sessionId),
             manualResume: null,
             currentTurnStatus: this.getCurrentTurnStatus(),
-            capabilities: { compact: true, media: PROVIDER_MEDIA_CAPABILITIES[OPENCODE_PROVIDER_VARIANT] },
+            capabilities: { compact: true, clear: true, media: PROVIDER_MEDIA_CAPABILITIES[OPENCODE_PROVIDER_VARIANT] },
             pid: this.transport.pid || undefined,
         };
     }
@@ -1227,6 +1227,38 @@ export class OpencodeSdkSession extends EventEmitter {
      * @param {{ onProgress?: Function }} [options]
      * @returns {Promise<import("../shared.js").CompactResult>}
      */
+    /**
+     * Native clear: create a new session on the SAME opencode server (the server
+     * process and its event stream stay up); the old session is left untouched on
+     * disk, exactly like the boot path's `session.create`.
+     */
+    async runClear() {
+        if (this.closeRequested) {
+            throw this.createSessionClosedError();
+        }
+        if (this.currentTurn) {
+            throw createTurnError("Opencode 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();
+        if (typeof this.client?.session?.create !== "function") {
+            throw new Error("Opencode session create API is unavailable");
+        }
+        const session = await this.requestOrThrow(this.client.session.create({}, { throwOnError: true, responseStyle: "data" }));
+        this.applySessionInfo(session);
+        // A later re-boot must not reattach to the session we walked away from.
+        this.resumeSessionId = "";
+        this.history = [];
+        return {
+            clear: { status: "cleared", sessionId: this.sessionId || undefined },
+            usage: null,
+            metadata: {},
+        };
+    }
     async runCompact(request = {}, { onProgress = null } = {}) {
         if (this.closeRequested) {
             throw this.createSessionClosedError();

package/dist/shared.d.ts

@@ -100,6 +100,7 @@ export const TERMINAL_GOAL_STATUSES: ReadonlyArray<GoalStatus>;
  * @typedef {Object} SessionCapabilities
  * @property {boolean} [goal]
  * @property {boolean} [compact]
+ * @property {boolean} [clear]
  */
 /**
  * Manual context compaction (`/compact`) contract for providers that
@@ -124,6 +125,22 @@ export const TERMINAL_GOAL_STATUSES: ReadonlyArray<GoalStatus>;
  * @property {unknown} [usage]
  * @property {Record<string, unknown>} [metadata]
  */
+/**
+ * Native context clear (`/clear`) contract for providers that implement the
+ * optional `runClear` method and advertise `capabilities.clear === true`.
+ * Providers must NOT emit assistant messages while clearing; the caller
+ * renders the user-facing confirmation.
+ *
+ * @typedef {Object} ClearState
+ * @property {"cleared"|"noop"} status `noop` = there was nothing to clear.
+ * @property {string} [sessionId] New session id when the backend starts a new
+ *   conversation; callers rebind the task to it.
+ *
+ * @typedef {Object} ClearResult
+ * @property {ClearState} clear
+ * @property {unknown} [usage]
+ * @property {Record<string, unknown>} [metadata]
+ */
 /**
  * Default capabilities assigned to providers that do not opt into any optional
  * feature. Treat the returned object as read-only; clone before mutating.
@@ -212,6 +229,7 @@ export type GoalResult = {
 export type SessionCapabilities = {
     goal?: boolean | undefined;
     compact?: boolean | undefined;
+    clear?: boolean | undefined;
 };
 /**
  * Manual context compaction (`/compact`) contract for providers that
@@ -254,3 +272,31 @@ export type CompactResult = {
     usage?: unknown;
     metadata?: Record<string, unknown> | undefined;
 };
+/**
+ * Native context clear (`/clear`) contract for providers that implement the
+ * optional `runClear` method and advertise `capabilities.clear === true`.
+ * Providers must NOT emit assistant messages while clearing; the caller
+ * renders the user-facing confirmation.
+ */
+export type ClearState = {
+    /**
+     * `noop` = there was nothing to clear.
+     */
+    status: "cleared" | "noop";
+    /**
+     * New session id when the backend starts a new
+     * conversation; callers rebind the task to it.
+     */
+    sessionId?: string | undefined;
+};
+/**
+ * Native context clear (`/clear`) contract for providers that implement the
+ * optional `runClear` method and advertise `capabilities.clear === true`.
+ * Providers must NOT emit assistant messages while clearing; the caller
+ * renders the user-facing confirmation.
+ */
+export type ClearResult = {
+    clear: ClearState;
+    usage?: unknown;
+    metadata?: Record<string, unknown> | undefined;
+};

package/dist/shared.js

@@ -81,6 +81,7 @@ export function isTerminalGoalStatus(value) {
  * @typedef {Object} SessionCapabilities
  * @property {boolean} [goal]
  * @property {boolean} [compact]
+ * @property {boolean} [clear]
  */
 /**
  * Manual context compaction (`/compact`) contract for providers that
@@ -105,13 +106,29 @@ export function isTerminalGoalStatus(value) {
  * @property {unknown} [usage]
  * @property {Record<string, unknown>} [metadata]
  */
+/**
+ * Native context clear (`/clear`) contract for providers that implement the
+ * optional `runClear` method and advertise `capabilities.clear === true`.
+ * Providers must NOT emit assistant messages while clearing; the caller
+ * renders the user-facing confirmation.
+ *
+ * @typedef {Object} ClearState
+ * @property {"cleared"|"noop"} status `noop` = there was nothing to clear.
+ * @property {string} [sessionId] New session id when the backend starts a new
+ *   conversation; callers rebind the task to it.
+ *
+ * @typedef {Object} ClearResult
+ * @property {ClearState} clear
+ * @property {unknown} [usage]
+ * @property {Record<string, unknown>} [metadata]
+ */
 /**
  * Default capabilities assigned to providers that do not opt into any optional
  * feature. Treat the returned object as read-only; clone before mutating.
  *
  * @type {Readonly<SessionCapabilities>}
  */
-export const DEFAULT_SESSION_CAPABILITIES = Object.freeze({ goal: false, compact: false });
+export const DEFAULT_SESSION_CAPABILITIES = Object.freeze({ goal: false, compact: false, clear: false });
 /**
  * Resolve a session's capability snapshot, falling back to
  * {@link DEFAULT_SESSION_CAPABILITIES}.

package/dist/transports/kimi-wire-transport.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Drop resume flags from the configured command line. The session id is owned
+ * by the caller (we always append our own `--session=`), so a configured
+ * `--continue`/`--session`/`--resume` would silently reattach a fresh session —
+ * e.g. a `/clear` — to the previous conversation.
+ *
+ * Only those flags are touched. Notably `-c` is kimi's alias for
+ * `--prompt`/`--command` (it takes a value), not a continue switch, so it is
+ * passed through untouched — dropping the flag alone would leave its value
+ * behind as a stray positional argument.
+ */
+export function filterKimiWireBaseArgs(args: any): string[];
 export class KimiWireTransport extends EventEmitter<[never]> {
     constructor(options?: {});
     options: {};

package/dist/transports/kimi-wire-transport.js

@@ -37,6 +37,45 @@ function quoteShellArg(value) {
     }
     return `'${normalized.replace(/'/g, `'\\''`)}'`;
 }
+/**
+ * Drop resume flags from the configured command line. The session id is owned
+ * by the caller (we always append our own `--session=`), so a configured
+ * `--continue`/`--session`/`--resume` would silently reattach a fresh session —
+ * e.g. a `/clear` — to the previous conversation.
+ *
+ * Only those flags are touched. Notably `-c` is kimi's alias for
+ * `--prompt`/`--command` (it takes a value), not a continue switch, so it is
+ * passed through untouched — dropping the flag alone would leave its value
+ * behind as a stray positional argument.
+ */
+export function filterKimiWireBaseArgs(args) {
+    const filtered = [];
+    let skipNext = false;
+    for (const rawArg of Array.isArray(args) ? args : []) {
+        const arg = String(rawArg || "");
+        if (!arg) {
+            continue;
+        }
+        if (skipNext) {
+            skipNext = false;
+            continue;
+        }
+        if (arg === "--continue" || arg === "-C") {
+            continue;
+        }
+        if (arg === "--session" || arg === "-S" || arg === "--resume" || arg === "-r") {
+            skipNext = true;
+            continue;
+        }
+        if (arg.startsWith("--session=") ||
+            arg.startsWith("--resume=") ||
+            ["-S", "-r"].some((prefix) => arg.startsWith(prefix) && arg.length > prefix.length)) {
+            continue;
+        }
+        filtered.push(arg);
+    }
+    return filtered;
+}
 export class KimiWireTransport extends EventEmitter {
     constructor(options = {}) {
         super();
@@ -55,7 +94,7 @@ export class KimiWireTransport extends EventEmitter {
             throw new Error("Invalid kimi command");
         }
         this.command = command;
-        this.baseArgs = args;
+        this.baseArgs = filterKimiWireBaseArgs(args);
         this.env = options.env && typeof options.env === "object" ? { ...options.env } : {};
         this.sessionId =
             typeof options.sessionId === "string" && options.sessionId.trim()

package/dist/turn-usage.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @typedef {object} TurnUsageSummary
+ * @property {number} tokens Everything the turn read and wrote.
+ * @property {number} [inputTokens] All input the model read, cached or not.
+ * @property {number} [cachedInputTokens] The part of `inputTokens` served from the prompt cache.
+ */
+/**
+ * Normalizes one turn's provider usage; the input cache hit ratio is
+ * `cachedInputTokens / inputTokens`. Claude's `input_tokens` excludes cache
+ * reads and writes, so its input is all three; the Codex provider reports
+ * per-turn deltas whose `turnInputTokens` already include the cached ones.
+ * Unknown shapes → null.
+ *
+ * @param {unknown} usage
+ * @returns {TurnUsageSummary | null}
+ */
+export function summarizeTurnUsage(usage: unknown): TurnUsageSummary | null;
+export type TurnUsageSummary = {
+    /**
+     * Everything the turn read and wrote.
+     */
+    tokens: number;
+    /**
+     * All input the model read, cached or not.
+     */
+    inputTokens?: number | undefined;
+    /**
+     * The part of `inputTokens` served from the prompt cache.
+     */
+    cachedInputTokens?: number | undefined;
+};

package/dist/turn-usage.js

@@ -0,0 +1,44 @@
+/**
+ * @typedef {object} TurnUsageSummary
+ * @property {number} tokens Everything the turn read and wrote.
+ * @property {number} [inputTokens] All input the model read, cached or not.
+ * @property {number} [cachedInputTokens] The part of `inputTokens` served from the prompt cache.
+ */
+/**
+ * Normalizes one turn's provider usage; the input cache hit ratio is
+ * `cachedInputTokens / inputTokens`. Claude's `input_tokens` excludes cache
+ * reads and writes, so its input is all three; the Codex provider reports
+ * per-turn deltas whose `turnInputTokens` already include the cached ones.
+ * Unknown shapes → null.
+ *
+ * @param {unknown} usage
+ * @returns {TurnUsageSummary | null}
+ */
+export function summarizeTurnUsage(usage) {
+    if (!usage || typeof usage !== "object") {
+        return null;
+    }
+    const read = (key) => {
+        const value = Number(/** @type {Record<string, unknown>} */ (usage)[key]);
+        return Number.isFinite(value) ? value : null;
+    };
+    const turnTotal = read("turnTotalTokens");
+    if (turnTotal !== null) {
+        const inputTokens = read("turnInputTokens");
+        const cachedInputTokens = read("turnCachedInputTokens");
+        return inputTokens !== null && cachedInputTokens !== null
+            ? { tokens: turnTotal, inputTokens, cachedInputTokens }
+            : { tokens: turnTotal };
+    }
+    const [input, cacheWrite, cacheRead, output] = [
+        "input_tokens",
+        "cache_creation_input_tokens",
+        "cache_read_input_tokens",
+        "output_tokens",
+    ].map(read);
+    if ([input, cacheWrite, cacheRead, output].every((value) => value === null)) {
+        return null;
+    }
+    const inputTokens = (input ?? 0) + (cacheWrite ?? 0) + (cacheRead ?? 0);
+    return { tokens: inputTokens + (output ?? 0), inputTokens, cachedInputTokens: cacheRead ?? 0 };
+}

package/dist/worker.js

@@ -76,7 +76,7 @@ async function handleRequest(message) {
         throw new Error(`Unsupported worker method: ${method}`);
     }
     const args = Array.isArray(message.args) ? [...message.args] : [];
-    if (method === "runTurn" || method === "runGoal" || method === "runCompact") {
+    if (method === "runTurn" || method === "runGoal" || method === "runCompact" || method === "runClear") {
         const firstArg = args[0];
         const options = args[1] && typeof args[1] === "object" ? { ...args[1] } : {};
         options.onProgress = (payload) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/ai-sdk",
-  "version": "0.13.3",
+  "version": "0.14.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -53,12 +53,12 @@
     "zod": "^4.1.5"
   },
   "optionalDependencies": {
-    "@love-moon/chat-web": "^0.13.3"
+    "@love-moon/chat-web": "^0.14.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
     "tsx": "^4.20.6",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "d61c070"
+  "gitCommitId": "6def94c"
 }