@love-moon/ai-sdk 0.7.3 → 0.7.4

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @love-moon/ai-sdk
 
+## 0.7.4
+
+### Patch Changes
+
+- d5eca1c: Adapt Codex quota parsing to the 0.144 weekly-only limit while retaining compatibility with legacy header layouts and cached snapshots.
+- d5eca1c: Support Kimi Code CLI prompt sessions, current session storage, and credential locations while retaining legacy Kimi wire compatibility.
+
 ## 0.7.3
 
 ### Patch Changes

package/dist/manager/paths.d.ts

@@ -2,5 +2,7 @@ export declare function expandHome(p: string): string;
 export declare const DEFAULT_CONDUCTOR_CONFIG: string;
 export declare const DEFAULT_CODEX_AUTH: string;
 export declare const DEFAULT_CODEX_CONFIG: string;
+export declare const DEFAULT_KIMI_CODE_HOME: string;
 export declare const DEFAULT_KIMI_CREDENTIAL: string;
+export declare const LEGACY_KIMI_CREDENTIAL: string;
 export declare const DEFAULT_QUOTA_CACHE_DIR: string;

package/dist/manager/paths.js

@@ -12,5 +12,7 @@ export function expandHome(p) {
 export const DEFAULT_CONDUCTOR_CONFIG = join(homedir(), ".conductor", "config.yaml");
 export const DEFAULT_CODEX_AUTH = join(homedir(), ".codex", "auth.json");
 export const DEFAULT_CODEX_CONFIG = join(homedir(), ".codex", "config.toml");
-export const DEFAULT_KIMI_CREDENTIAL = join(homedir(), ".kimi", "credentials", "kimi-code.json");
+export const DEFAULT_KIMI_CODE_HOME = process.env.KIMI_CODE_HOME?.trim() || join(homedir(), ".kimi-code");
+export const DEFAULT_KIMI_CREDENTIAL = join(DEFAULT_KIMI_CODE_HOME, "credentials", "kimi-code.json");
+export const LEGACY_KIMI_CREDENTIAL = join(homedir(), ".kimi", "credentials", "kimi-code.json");
 export const DEFAULT_QUOTA_CACHE_DIR = join(homedir(), ".conductor", "cache", "ai-manager");

package/dist/manager/quota/codex.d.ts

@@ -14,6 +14,11 @@ export interface GetCodexQuotaOptions {
     /** Override cache directory (mainly for tests). */
     cacheDir?: string;
 }
+/** Exported for protocol compatibility tests. */
+export declare function parseCodexHeaders(map: Record<string, string>, extras: {
+    email?: string;
+    accountId?: string;
+}): Omit<CodexQuota, "tool" | "fetchedAt" | "source">;
 export declare function getCodexQuota(opts?: GetCodexQuotaOptions): Promise<CodexQuota>;
 /**
  * Read the on-disk quota cache for a given codex auth.json without triggering

package/dist/manager/quota/codex.js

@@ -33,6 +33,15 @@ const RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
 const DEFAULT_TTL = 60; // seconds
 const DEFAULT_TIMEOUT_MS = 15000;
 function windowFromHeaders(map, prefix) {
+    const suffixes = [
+        "used-percent",
+        "reset-after-seconds",
+        "reset-at",
+        "window-minutes",
+    ];
+    if (!suffixes.some((suffix) => map[`${prefix}-${suffix}`] !== undefined)) {
+        return undefined;
+    }
     const usedPercent = num(map, `${prefix}-used-percent`) ?? 0;
     return {
         usedPercent,
@@ -42,12 +51,19 @@ function windowFromHeaders(map, prefix) {
         windowMinutes: num(map, `${prefix}-window-minutes`),
     };
 }
-function parseCodexHeaders(map, extras) {
+/** Exported for protocol compatibility tests. */
+export function parseCodexHeaders(map, extras) {
+    const primary = windowFromHeaders(map, "x-codex-primary");
+    const secondary = windowFromHeaders(map, "x-codex-secondary");
+    // Codex CLI 0.144 removed the 5h limit. Its only Codex window is now the
+    // 10080-minute weekly window in `primary`, with `secondary` absent. Older
+    // responses used primary=5h and secondary=weekly, so prefer an explicitly
+    // weekly-sized window and then fall back to the legacy secondary position.
+    const weekly = [primary, secondary].find((window) => (window?.windowMinutes ?? 0) >= 7 * 24 * 60) ?? secondary ?? primary ?? { usedPercent: 0, remainingPercent: 0 };
     return {
         plan: str(map, "x-codex-plan-type"),
         activeLimit: str(map, "x-codex-active-limit"),
-        fiveHour: windowFromHeaders(map, "x-codex-primary"),
-        weekly: windowFromHeaders(map, "x-codex-secondary"),
+        weekly,
         credits: {
             hasCredits: bool(map, "x-codex-credits-has-credits") ?? false,
             balance: str(map, "x-codex-credits-balance"),
@@ -71,7 +87,7 @@ export async function getCodexQuota(opts = {}) {
     if (!opts.forceRefresh && ttl > 0) {
         const cached = await readCache(file);
         if (isFresh(cached, ttl) && cached) {
-            return { ...cached.value, source: "cached" };
+            return { ...withoutLegacyFiveHour(cached.value), source: "cached" };
         }
     }
     const model = opts.model ??
@@ -140,7 +156,7 @@ async function fallbackFromCache(file, ttl, error) {
     const cached = await readCache(file);
     if (cached) {
         return {
-            ...cached.value,
+            ...withoutLegacyFiveHour(cached.value),
             source: isFresh(cached, ttl) ? "cached" : "stale",
             error,
         };
@@ -164,19 +180,26 @@ export async function readCachedCodexQuota(codexAuthPath, opts = {}) {
         const entry = await readCache(file);
         if (!entry)
             return null;
-        return { ...entry.value, source: "cached", fetchedAt: entry.fetchedAt };
+        return {
+            ...withoutLegacyFiveHour(entry.value),
+            source: "cached",
+            fetchedAt: entry.fetchedAt,
+        };
     }
     catch {
         return null;
     }
 }
+function withoutLegacyFiveHour(quota) {
+    const { fiveHour: _legacyFiveHour, ...current } = quota;
+    return current;
+}
 function emptyQuota(source, error) {
     return {
         tool: "codex",
         source,
         error,
         fetchedAt: Math.floor(Date.now() / 1000),
-        fiveHour: { usedPercent: 0, remainingPercent: 0 },
         weekly: { usedPercent: 0, remainingPercent: 0 },
     };
 }

package/dist/manager/quota/kimi.js

@@ -1,5 +1,5 @@
 import { readFile, writeFile, rename } from "node:fs/promises";
-import { DEFAULT_KIMI_CREDENTIAL } from "../paths.js";
+import { DEFAULT_KIMI_CREDENTIAL, LEGACY_KIMI_CREDENTIAL } from "../paths.js";
 import { cacheFile, fingerprintKey, isFresh, readCache, writeCache } from "./cache.js";
 const USAGE_URL = "https://api.kimi.com/coding/v1/usages";
 const OAUTH_TOKEN_URL = "https://auth.kimi.com/api/oauth/token";
@@ -8,19 +8,32 @@ const DEFAULT_TTL = 60;
 const DEFAULT_TIMEOUT_MS = 15_000;
 const REFRESH_LEEWAY_SECONDS = 60;
 export async function getKimiQuota(opts = {}) {
-    const credentialPath = opts.credentialPath ?? DEFAULT_KIMI_CREDENTIAL;
+    const credentialPaths = opts.credentialPath
+        ? [opts.credentialPath]
+        : [DEFAULT_KIMI_CREDENTIAL, LEGACY_KIMI_CREDENTIAL];
     const ttl = opts.ttlSeconds ?? DEFAULT_TTL;
     const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const doFetch = opts.fetcher ?? fetch;
+    let credentialPath = credentialPaths[0];
     let cred;
-    try {
-        cred = JSON.parse(await readFile(credentialPath, "utf8"));
-    }
-    catch (err) {
-        return emptyQuota("unknown", `kimi credential not readable: ${err?.message ?? err}`);
+    let credentialError = "credential missing access_token";
+    for (const candidatePath of credentialPaths) {
+        try {
+            const candidate = JSON.parse(await readFile(candidatePath, "utf8"));
+            if (!candidate.access_token) {
+                credentialError = "credential missing access_token";
+                continue;
+            }
+            credentialPath = candidatePath;
+            cred = candidate;
+            break;
+        }
+        catch (err) {
+            credentialError = `credential not readable: ${err?.message ?? err}`;
+        }
     }
-    if (!cred.access_token) {
-        return emptyQuota("unknown", "kimi credential missing access_token");
+    if (!cred) {
+        return emptyQuota("unknown", `kimi ${credentialError}`);
     }
     const fp = fingerprintKey(["kimi", cred.access_token.slice(-32)]);
     const file = cacheFile("kimi", fp, opts.cacheDir);

package/dist/manager/types.d.ts

@@ -37,7 +37,8 @@ export interface CodexQuota {
     tool: "codex";
     plan?: string;
     activeLimit?: string;
-    fiveHour: QuotaWindow;
+    /** @deprecated Codex CLI 0.144+ no longer exposes a 5h limit. */
+    fiveHour?: QuotaWindow;
     weekly: QuotaWindow;
     credits?: {
         hasCredits: boolean;

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

@@ -0,0 +1 @@
+export function resolveKimiCliMode(options?: {}): Promise<"prompt" | "wire">;

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

@@ -0,0 +1,115 @@
+import { spawn } from "node:child_process";
+import { emitLog, normalizeLogger, parseCommandParts, sanitizeForLog, } from "../shared.js";
+const DEFAULT_KIMI_COMMAND = "kimi";
+const DEFAULT_PROBE_TIMEOUT_MS = 5_000;
+const MAX_PROBE_OUTPUT_CHARS = 128 * 1024;
+function normalizeMode(value) {
+    const normalized = String(value || "").trim().toLowerCase();
+    if (normalized === "prompt" || normalized === "kimi-code" || normalized === "modern") {
+        return "prompt";
+    }
+    if (normalized === "wire" || normalized === "legacy") {
+        return "wire";
+    }
+    return "";
+}
+function resolveCommandLine(options = {}) {
+    return (process.env.CONDUCTOR_KIMI_COMMAND ||
+        options.commandLine ||
+        process.env.CONDUCTOR_CLI_COMMAND ||
+        DEFAULT_KIMI_COMMAND);
+}
+function appendProbeOutput(current, chunk) {
+    if (current.length >= MAX_PROBE_OUTPUT_CHARS) {
+        return current;
+    }
+    return `${current}${String(chunk || "")}`.slice(0, MAX_PROBE_OUTPUT_CHARS);
+}
+async function readKimiHelp(options = {}) {
+    const { command, args } = parseCommandParts(resolveCommandLine(options));
+    if (!command) {
+        throw new Error("Invalid kimi command");
+    }
+    const cwd = typeof options.cwd === "string" && options.cwd.trim()
+        ? options.cwd.trim()
+        : process.cwd();
+    const env = {
+        ...process.env,
+        ...(options.env && typeof options.env === "object" ? options.env : {}),
+    };
+    return await new Promise((resolve, reject) => {
+        const child = spawn(command, [...args, "--help"], {
+            cwd,
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let output = "";
+        let settled = false;
+        const timeoutMs = Number.isFinite(options.kimiCliProbeTimeoutMs)
+            ? Math.max(100, Number(options.kimiCliProbeTimeoutMs))
+            : DEFAULT_PROBE_TIMEOUT_MS;
+        const timeoutId = setTimeout(() => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            try {
+                child.kill("SIGTERM");
+            }
+            catch {
+                // best effort
+            }
+            reject(new Error(`Kimi CLI capability probe timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        child.stdout.on("data", (chunk) => {
+            output = appendProbeOutput(output, chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            output = appendProbeOutput(output, chunk);
+        });
+        child.once("error", (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeoutId);
+            reject(error);
+        });
+        child.once("close", () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeoutId);
+            resolve(output);
+        });
+    });
+}
+export async function resolveKimiCliMode(options = {}) {
+    if (options.transport) {
+        return "wire";
+    }
+    const configuredMode = normalizeMode(options.kimiCliMode ||
+        options.env?.CONDUCTOR_KIMI_CLI_MODE ||
+        process.env.CONDUCTOR_KIMI_CLI_MODE);
+    if (configuredMode) {
+        return configuredMode;
+    }
+    const logger = normalizeLogger(options.logger);
+    try {
+        const helpText = await readKimiHelp(options);
+        if (/(^|\s)--wire(?:\s|$)/m.test(helpText)) {
+            emitLog(logger, "[kimi-detect] using legacy wire mode");
+            return "wire";
+        }
+        if (/(^|\s)--prompt(?:\s|,|$)/m.test(helpText) && helpText.includes("--output-format")) {
+            emitLog(logger, "[kimi-detect] using Kimi Code prompt mode");
+            return "prompt";
+        }
+        emitLog(logger, "[kimi-detect] CLI mode was not recognized; keeping legacy wire mode");
+    }
+    catch (error) {
+        emitLog(logger, `[kimi-detect] capability probe failed; keeping legacy wire mode: ${sanitizeForLog(error?.message || error, 180)}`);
+    }
+    return "wire";
+}

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

@@ -4,11 +4,13 @@ export class KimiPrintSession extends EventEmitter<[never]> {
     options: {};
     logger: any;
     cwd: any;
+    cliMode: string;
     resumeSessionId: any;
     sessionId: any;
     sessionInfo: {
         backend: string;
         sessionId: any;
+        sessionIdDeferred: boolean;
         model: any;
     };
     history: any[];
@@ -21,6 +23,7 @@ export class KimiPrintSession extends EventEmitter<[never]> {
         items: never[];
         stderrTail: never[];
         settled: boolean;
+        interruptRequested: boolean;
     } | null;
     currentTurnStatus: any;
     sessionAnnounced: boolean;
@@ -47,6 +50,7 @@ export class KimiPrintSession extends EventEmitter<[never]> {
         sessionInfo: {
             backend: string;
             sessionId: any;
+            sessionIdDeferred: boolean;
             model: any;
         } | null;
         useSessionFileReplyStream: boolean;
@@ -61,12 +65,14 @@ export class KimiPrintSession extends EventEmitter<[never]> {
     getSessionInfo(): {
         backend: string;
         sessionId: any;
+        sessionIdDeferred: boolean;
         model: any;
     } | null;
     getCurrentTurnStatus(): any;
     ensureSessionInfo(): Promise<{
         backend: string;
         sessionId: any;
+        sessionIdDeferred: boolean;
         model: any;
     } | null>;
     getSessionUsageSummary(): Promise<{
@@ -87,12 +93,13 @@ export class KimiPrintSession extends EventEmitter<[never]> {
     setSessionReplyTarget(replyTo: any): void;
     getCurrentReplyTarget(): string | undefined;
     announceSession(): void;
+    adoptSessionId(sessionId: any): void;
     createSessionClosedError(): Error;
     updateCurrentTurnStatus(payload: any): void;
     emitWorkingStatus(payload: any, onProgress?: null): Promise<any>;
     emitAssistantMessage(text: any): Promise<void>;
     buildPrompt(promptText: any): string;
-    buildPrintArgs(): string[];
+    buildPrintArgs(promptText?: string): string[];
     buildUserMessage(promptText: any, { useInitialImages }?: {
         useInitialImages?: boolean | undefined;
     }): {
@@ -100,6 +107,7 @@ export class KimiPrintSession extends EventEmitter<[never]> {
         content: any;
     };
     maybeEmitAuthRequired(stderrTail: any): void;
+    interruptCurrentTurn(): Promise<boolean>;
     runTurn(promptText: any, { useInitialImages, onProgress, jsonSchema }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;

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

@@ -85,7 +85,7 @@ function statusLineForPhase(phase) {
             return "Kimi is working";
     }
 }
-function filterKimiPrintBaseArgs(args) {
+function filterKimiPrintBaseArgs(args, cliMode = "legacy-print") {
     const filtered = [];
     let skipNext = false;
     for (const rawArg of Array.isArray(args) ? args : []) {
@@ -97,7 +97,18 @@ function filterKimiPrintBaseArgs(args) {
             skipNext = false;
             continue;
         }
-        if (arg === "--wire" || arg === "--print" || arg === "--final-message-only") {
+        if (arg === "--wire" ||
+            arg === "--print" ||
+            arg === "--final-message-only" ||
+            arg === "--yolo" ||
+            arg === "--yes" ||
+            arg === "--auto-approve" ||
+            arg === "--auto" ||
+            arg === "--plan" ||
+            arg === "--continue" ||
+            arg === "-C" ||
+            arg === "-y" ||
+            (cliMode === "prompt" && arg === "-c")) {
             continue;
         }
         if (arg === "--input-format" ||
@@ -105,8 +116,15 @@ function filterKimiPrintBaseArgs(args) {
             arg === "--prompt" ||
             arg === "--command" ||
             arg === "--session" ||
+            arg === "--resume" ||
             arg === "--work-dir" ||
-            arg === "--model") {
+            arg === "--model" ||
+            arg === "-S" ||
+            arg === "-r" ||
+            arg === "-m" ||
+            arg === "-p" ||
+            arg === "-w" ||
+            (cliMode === "legacy-print" && arg === "-c")) {
             skipNext = true;
             continue;
         }
@@ -115,14 +133,26 @@ function filterKimiPrintBaseArgs(args) {
             arg.startsWith("--prompt=") ||
             arg.startsWith("--command=") ||
             arg.startsWith("--session=") ||
+            arg.startsWith("--resume=") ||
             arg.startsWith("--work-dir=") ||
-            arg.startsWith("--model=")) {
+            arg.startsWith("--model=") ||
+            ["-S", "-r", "-m", "-p", "-w", "-c"].some((prefix) => arg.startsWith(prefix) && arg.length > prefix.length)) {
             continue;
         }
         filtered.push(arg);
     }
     return filtered;
 }
+function quoteShellArg(value) {
+    const normalized = String(value ?? "");
+    if (!normalized) {
+        return "''";
+    }
+    if (/^[A-Za-z0-9_./:@%+=,-]+$/.test(normalized)) {
+        return normalized;
+    }
+    return `'${normalized.replace(/'/g, `'\\''`)}'`;
+}
 function normalizeTextContent(content) {
     if (typeof content === "string") {
         return content;
@@ -170,11 +200,13 @@ export class KimiPrintSession extends EventEmitter {
             typeof options.cwd === "string" && options.cwd.trim()
                 ? options.cwd.trim()
                 : process.cwd();
+        this.cliMode = options.kimiCliMode === "prompt" ? "prompt" : "legacy-print";
         this.resumeSessionId = typeof options.resumeSessionId === "string" ? options.resumeSessionId.trim() : "";
-        this.sessionId = this.resumeSessionId || randomUUID();
+        this.sessionId = this.resumeSessionId || (this.cliMode === "prompt" ? "" : randomUUID());
         this.sessionInfo = {
             backend: this.backend,
-            sessionId: this.sessionId,
+            sessionId: this.sessionId || undefined,
+            sessionIdDeferred: this.cliMode === "prompt" && !this.sessionId,
             model: typeof options.model === "string" && options.model.trim()
                 ? options.model.trim()
                 : this.backend,
@@ -207,7 +239,7 @@ export class KimiPrintSession extends EventEmitter {
             throw new Error("Invalid kimi print command");
         }
         this.command = command;
-        this.baseArgs = filterKimiPrintBaseArgs(args);
+        this.baseArgs = filterKimiPrintBaseArgs(args, this.cliMode);
     }
     writeLog(message) {
         emitLog(this.logger, message);
@@ -227,7 +259,21 @@ export class KimiPrintSession extends EventEmitter {
         };
     }
     buildManualResumeCommand() {
-        return `kimi --work-dir ${this.cwd} --session ${this.sessionId}`;
+        if (!this.sessionId) {
+            return "";
+        }
+        const parts = [...this.baseArgs];
+        if (this.cliMode === "legacy-print") {
+            parts.push("--work-dir", this.cwd);
+        }
+        parts.push("--session", this.sessionId);
+        if (typeof this.options.model === "string" && this.options.model.trim()) {
+            parts.push("--model", this.options.model.trim());
+        }
+        const command = [this.command, ...parts].map(quoteShellArg).join(" ");
+        return this.cliMode === "prompt"
+            ? `cd ${quoteShellArg(this.cwd)} && ${command}`
+            : command;
     }
     getSnapshot() {
         return {
@@ -255,7 +301,9 @@ export class KimiPrintSession extends EventEmitter {
         return this.currentTurnStatus ? { ...this.currentTurnStatus } : null;
     }
     async ensureSessionInfo() {
-        this.announceSession();
+        if (!this.sessionInfo?.sessionIdDeferred) {
+            this.announceSession();
+        }
         return this.getSessionInfo();
     }
     async getSessionUsageSummary() {
@@ -294,12 +342,26 @@ export class KimiPrintSession extends EventEmitter {
         return this.activeReplyTarget || this.lastReplyTarget || undefined;
     }
     announceSession() {
-        if (this.sessionAnnounced) {
+        if (this.sessionAnnounced || !this.sessionId) {
             return;
         }
         this.sessionAnnounced = true;
         this.emit("session", this.getSessionInfo());
     }
+    adoptSessionId(sessionId) {
+        const normalizedSessionId = typeof sessionId === "string" ? sessionId.trim() : "";
+        if (!normalizedSessionId || normalizedSessionId === this.sessionId) {
+            return;
+        }
+        this.sessionId = normalizedSessionId;
+        this.sessionInfo = {
+            ...this.sessionInfo,
+            sessionId: normalizedSessionId,
+            sessionIdDeferred: false,
+        };
+        this.trace(`session ready id=${sanitizeForLog(normalizedSessionId, 120)}`);
+        this.announceSession();
+    }
     createSessionClosedError() {
         return createTurnError("Kimi print session closed", {
             reason: "session_closed",
@@ -357,8 +419,19 @@ export class KimiPrintSession extends EventEmitter {
         this.pendingHistorySeed = false;
         return buildHistoryPrompt(this.history, normalizedPrompt);
     }
-    buildPrintArgs() {
+    buildPrintArgs(promptText = "") {
         const args = [...this.baseArgs];
+        if (this.cliMode === "prompt") {
+            args.push("--output-format=stream-json");
+            if (this.sessionId) {
+                args.push(`--session=${this.sessionId}`);
+            }
+            if (typeof this.options.model === "string" && this.options.model.trim()) {
+                args.push(`--model=${this.options.model.trim()}`);
+            }
+            args.push("--prompt", promptText);
+            return args;
+        }
         args.push("--print");
         args.push("--input-format=stream-json");
         args.push("--output-format=stream-json");
@@ -413,6 +486,20 @@ export class KimiPrintSession extends EventEmitter {
             message: lastMessage || "Kimi authentication required",
         });
     }
+    async interruptCurrentTurn() {
+        const currentTurn = this.currentTurn;
+        if (!currentTurn?.child) {
+            return false;
+        }
+        currentTurn.interruptRequested = true;
+        try {
+            currentTurn.child.kill("SIGINT");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     async runTurn(promptText, { useInitialImages = false, onProgress = null, jsonSchema = null } = {}) {
         if (this.closeRequested || this.closed) {
             throw this.createSessionClosedError();
@@ -432,6 +519,10 @@ export class KimiPrintSession extends EventEmitter {
                 effectivePrompt = injectJsonSchemaPrompt(promptWithSchema, jsonSchema);
             }
         }
+        if (this.cliMode === "prompt" && imagePaths.length > 0) {
+            const imageContext = imagePaths.map((item, index) => `${index + 1}. ${item}`).join("\n");
+            effectivePrompt = `${effectivePrompt || "Analyze the attached images."}\n\nAttached image files:\n${imageContext}`;
+        }
         if (!effectivePrompt && imagePaths.length === 0) {
             return buildEmptyTurnResult();
         }
@@ -443,6 +534,7 @@ export class KimiPrintSession extends EventEmitter {
             items: [],
             stderrTail: [],
             settled: false,
+            interruptRequested: false,
         };
         this.currentTurn = currentTurn;
         try {
@@ -451,8 +543,11 @@ export class KimiPrintSession extends EventEmitter {
                 reply_in_progress: true,
                 status_line: statusLineForPhase("turn_started"),
             }, onProgress);
-            const args = this.buildPrintArgs();
-            this.trace(`spawn ${[this.command, ...args].join(" ")}`);
+            const args = this.buildPrintArgs(effectivePrompt);
+            const argsForLog = this.cliMode === "prompt"
+                ? [...args.slice(0, -2), "--prompt", `<redacted:${effectivePrompt.length} chars>`]
+                : args;
+            this.trace(`spawn ${[this.command, ...argsForLog].join(" ")}`);
             const result = await new Promise((resolve, reject) => {
                 const child = spawn(this.command, args, {
                     cwd: this.cwd,
@@ -508,6 +603,13 @@ export class KimiPrintSession extends EventEmitter {
                     }
                     currentTurn.items.push(payload);
                     const role = String(payload?.role || "").trim().toLowerCase();
+                    if (role === "meta") {
+                        const type = String(payload?.type || "").trim().toLowerCase();
+                        if (type === "session.resume_hint") {
+                            this.adoptSessionId(payload?.session_id);
+                        }
+                        return;
+                    }
                     if (role === "assistant") {
                         const assistantText = normalizeTextContent(payload.content);
                         if (Array.isArray(payload?.tool_calls) && payload.tool_calls.length > 0) {
@@ -552,11 +654,19 @@ export class KimiPrintSession extends EventEmitter {
                 child.on("error", (error) => {
                     settle(error);
                 });
-                child.on("exit", (code, signal) => {
+                child.on("close", (code, signal) => {
                     if (this.closeRequested) {
                         settle(this.createSessionClosedError());
                         return;
                     }
+                    if (currentTurn.interruptRequested) {
+                        settle(createTurnError("Kimi print turn interrupted", {
+                            reason: "turn_interrupted",
+                            code,
+                            signal,
+                        }));
+                        return;
+                    }
                     if (code !== 0) {
                         this.maybeEmitAuthRequired(currentTurn.stderrTail);
                         const stderrSummary = sanitizeForLog(currentTurn.stderrTail.filter(Boolean).at(-1), 200);
@@ -574,8 +684,10 @@ export class KimiPrintSession extends EventEmitter {
                         items: [...currentTurn.items],
                     });
                 });
-                const userMessage = this.buildUserMessage(effectivePrompt, { useInitialImages });
-                child.stdin.write(`${JSON.stringify(userMessage)}\n`);
+                if (this.cliMode === "legacy-print") {
+                    const userMessage = this.buildUserMessage(effectivePrompt, { useInitialImages });
+                    child.stdin.write(`${JSON.stringify(userMessage)}\n`);
+                }
                 child.stdin.end();
             });
             if (result?.text) {

package/dist/resume/kimi.d.ts

@@ -1,5 +1,5 @@
 export function buildCliArgs(sessionId: any): string[];
-export function findSessionPath(sessionId: any, options?: {}): Promise<string | null>;
+export function findSessionPath(sessionId: any, options?: {}): Promise<any>;
 export function resolveResumeContext(sessionId: any, options?: {}): Promise<{
     provider: any;
     sessionId: any;

package/dist/resume/kimi.js

@@ -15,20 +15,20 @@ export async function findSessionPath(sessionId, options = {}) {
     if (!normalizedSessionId) {
         return null;
     }
-    const homeDir = resolveHomeDir(options);
-    const sessionsDir = options.kimiSessionsDir || path.join(homeDir, ".kimi", "sessions");
-    return findKimiSessionDirectory(sessionsDir, normalizedSessionId);
+    const target = await findKimiSessionTarget(normalizedSessionId, options);
+    return target?.sessionPath || null;
 }
 export async function resolveResumeContext(sessionId, options = {}) {
     const normalizedSessionId = normalizeSessionId(sessionId);
     if (!normalizedSessionId) {
         throw new Error("--resume requires a session id");
     }
-    const sessionPath = await findSessionPath(normalizedSessionId, options);
-    if (!sessionPath) {
+    const target = await findKimiSessionTarget(normalizedSessionId, options);
+    if (!target?.sessionPath) {
         throw new Error(`Invalid --resume session id for kimi: ${normalizedSessionId}`);
     }
-    const cwdFromSession = await resolveKimiResumeCwd(sessionPath, normalizedSessionId, options);
+    const sessionPath = target.sessionPath;
+    const cwdFromSession = target.cwd || (await resolveLegacyKimiResumeCwd(sessionPath, normalizedSessionId, options));
     if (!cwdFromSession) {
         throw new Error(`Could not resolve workspace for Kimi session ${normalizedSessionId}. Re-run from the original workspace or resume a session previously started by conductor fire.`);
     }
@@ -46,7 +46,7 @@ export async function resolveResumeContext(sessionId, options = {}) {
 export function md5Hex(value) {
     return crypto.createHash("md5").update(String(value ?? "")).digest("hex");
 }
-async function resolveKimiResumeCwd(sessionPath, _sessionId, options = {}) {
+async function resolveLegacyKimiResumeCwd(sessionPath, _sessionId, options = {}) {
     const sessionDirectory = typeof sessionPath === "string" ? sessionPath.trim() : "";
     if (!sessionDirectory) {
         return null;
@@ -68,6 +68,111 @@ async function resolveKimiResumeCwd(sessionPath, _sessionId, options = {}) {
     }
     return null;
 }
+async function findKimiSessionTarget(sessionId, options = {}) {
+    const homeDir = resolveHomeDir(options);
+    const kimiCodeHome = resolveKimiCodeHome(homeDir, options);
+    const kimiCodeTarget = await findKimiCodeSession(kimiCodeHome, sessionId);
+    if (kimiCodeTarget) {
+        return kimiCodeTarget;
+    }
+    const legacySessionsDir = options.kimiSessionsDir || path.join(homeDir, ".kimi", "sessions");
+    const legacySessionPath = await findKimiSessionDirectory(legacySessionsDir, sessionId);
+    return legacySessionPath
+        ? {
+            sessionPath: legacySessionPath,
+            cwd: null,
+        }
+        : null;
+}
+function resolveKimiCodeHome(homeDir, options = {}) {
+    const configured = options.kimiCodeHome ||
+        options.env?.KIMI_CODE_HOME ||
+        (!options.homeDir ? process.env.KIMI_CODE_HOME : "");
+    return typeof configured === "string" && configured.trim()
+        ? configured.trim()
+        : path.join(homeDir, ".kimi-code");
+}
+async function findKimiCodeSession(kimiCodeHome, sessionId) {
+    const sessionsDir = path.join(kimiCodeHome, "sessions");
+    const indexed = await findIndexedKimiCodeSession(kimiCodeHome, sessionsDir, sessionId);
+    if (indexed) {
+        return indexed;
+    }
+    const sessionPath = await findKimiSessionDirectory(sessionsDir, sessionId);
+    if (!sessionPath) {
+        return null;
+    }
+    return {
+        sessionPath,
+        cwd: await readKimiCodeSessionWorkDir(sessionPath),
+    };
+}
+async function findIndexedKimiCodeSession(kimiCodeHome, sessionsDir, sessionId) {
+    let raw = "";
+    try {
+        raw = await fsp.readFile(path.join(kimiCodeHome, "session_index.jsonl"), "utf8");
+    }
+    catch {
+        return null;
+    }
+    let matched = null;
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        let record = null;
+        try {
+            record = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (record?.sessionId !== sessionId) {
+            continue;
+        }
+        if (record?.deleted === true) {
+            matched = null;
+            continue;
+        }
+        const sessionDir = typeof record?.sessionDir === "string" ? record.sessionDir.trim() : "";
+        if (!sessionDir || !path.isAbsolute(sessionDir)) {
+            continue;
+        }
+        const relativePath = path.relative(path.resolve(sessionsDir), path.resolve(sessionDir));
+        if (!relativePath ||
+            relativePath === ".." ||
+            relativePath.startsWith(`..${path.sep}`) ||
+            path.isAbsolute(relativePath) ||
+            path.basename(sessionDir) !== sessionId) {
+            continue;
+        }
+        matched = {
+            sessionPath: sessionDir,
+            cwd: typeof record?.workDir === "string" ? record.workDir.trim() : "",
+        };
+    }
+    if (!matched || !(await pathExists(matched.sessionPath, "directory"))) {
+        return null;
+    }
+    return {
+        sessionPath: matched.sessionPath,
+        cwd: await readKimiCodeSessionWorkDir(matched.sessionPath, matched.cwd),
+    };
+}
+async function readKimiCodeSessionWorkDir(sessionPath, fallback = "") {
+    try {
+        const raw = await fsp.readFile(path.join(sessionPath, "state.json"), "utf8");
+        const state = JSON.parse(raw);
+        if (typeof state?.workDir === "string" && state.workDir.trim()) {
+            return state.workDir.trim();
+        }
+    }
+    catch {
+        // Fall back to the session index, which also records the working directory.
+    }
+    return typeof fallback === "string" && fallback.trim() ? fallback.trim() : null;
+}
 async function findKimiSessionDirectory(rootDir, sessionId) {
     let hashDirs = [];
     try {

package/dist/session-factory.js

@@ -5,6 +5,7 @@ import { CodexExecSession } from "./providers/codex-exec-session.js";
 import { ClaudeAgentSdkSession } from "./providers/claude-agent-sdk-session.js";
 import { CopilotSdkSession } from "./providers/copilot-sdk-session.js";
 import { KimiCliSession } from "./providers/kimi-cli-session.js";
+import { resolveKimiCliMode } from "./providers/kimi-cli-mode.js";
 import { KimiPrintSession } from "./providers/kimi-print-session.js";
 import { OpencodeSdkSession } from "./providers/opencode-sdk-session.js";
 import { getExternalProviderDescriptor, resolveExternalBackend, } from "./external-provider-registry.js";
@@ -36,9 +37,13 @@ const SESSION_FACTORIES_BY_BACKEND = new Map([
     ["copilot", (backend, options) => new CopilotSdkSession(backend, options)],
     [
         "kimi",
-        (backend, options) => hasStructuredOutputPreference(options)
-            ? new KimiPrintSession(backend, options)
-            : new KimiCliSession(backend, options),
+        async (backend, options) => {
+            const kimiCliMode = await resolveKimiCliMode(options);
+            const resolvedOptions = { ...options, kimiCliMode };
+            return hasStructuredOutputPreference(options) || kimiCliMode === "prompt"
+                ? new KimiPrintSession(backend, resolvedOptions)
+                : new KimiCliSession(backend, resolvedOptions);
+        },
     ],
     ["opencode", (backend, options) => new OpencodeSdkSession(backend, options)],
     ["chat-web", (backend, options) => new ChatWebSession(backend, options)],
@@ -109,7 +114,7 @@ export async function createLocalAiSession(backend, options = {}) {
     const normalized = await assertSupportedBackend(backend, options);
     const factory = SESSION_FACTORIES_BY_BACKEND.get(normalized);
     if (factory) {
-        return factory(normalized, options);
+        return await factory(normalized, options);
     }
     const descriptor = await getExternalProviderDescriptor(normalized, options);
     if (!descriptor) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/ai-sdk",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "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.3"
+    "@love-moon/chat-web": "^0.7.4"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
     "tsx": "^4.20.6",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "8081263"
+  "gitCommitId": "b9a27b4"
 }