@love-moon/ai-sdk 0.7.3 → 0.7.5

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @love-moon/ai-sdk
 
+## 0.7.5
+
+### Patch Changes
+
+- f91a5df: Read Codex weekly quota from the official app-server account rate-limit RPC, ignore model-specific buckets, and invalidate legacy response-header caches.
+
+## 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

@@ -7,20 +7,28 @@ export interface GetCodexQuotaOptions {
     forceRefresh?: boolean;
     /** Request timeout in ms. */
     timeoutMs?: number;
-    /** Model name; defaults to the one in ~/.codex/config.toml, then `gpt-5`. */
+    /** @deprecated Quota is account-scoped and no longer fetched through a model response. */
     model?: string;
-    /** Override path to codex config.toml (to detect model). */
+    /** @deprecated The Codex app-server reads its own config from CODEX_HOME. */
     codexConfigPath?: string;
     /** Override cache directory (mainly for tests). */
     cacheDir?: string;
+    /** Override the app-server reader (tests only). */
+    rateLimitsReader?: (options: {
+        codexAuthPath: string;
+        timeoutMs: number;
+    }) => Promise<unknown>;
 }
+/** Normalize Codex app-server `account/rateLimits/read` into the manager shape. */
+export declare function parseCodexRateLimitsResponse(response: unknown, 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
- * any network call. Returns whatever snapshot was last written (regardless of
- * age) or `null` if nothing has been cached for this identity yet. Used by the
- * daemon's `list_accounts` handler to surface "last known" quota for inactive
- * accounts so the web UI can restore them across page refreshes.
+ * any network call. Only app-server snapshots are considered; legacy caches
+ * from response headers are intentionally ignored.
  */
 export declare function readCachedCodexQuota(codexAuthPath: string, opts?: {
     cacheDir?: string;

package/dist/manager/quota/codex.js

@@ -1,61 +1,72 @@
-import { readFile } from "node:fs/promises";
+import { basename, dirname } from "node:path";
 import { parseAuthFile } from "../auth-parser.js";
-import { DEFAULT_CODEX_AUTH, DEFAULT_CODEX_CONFIG } from "../paths.js";
-import { bool, headersToMap, num, str } from "./headers.js";
+import { DEFAULT_CODEX_AUTH } from "../paths.js";
+import { CodexAppServerTransport } from "../../transports/codex-app-server-transport.js";
 import { cacheFile, fingerprintKey, isFresh, readCache, writeCache } from "./cache.js";
-/** Best-effort: read the configured model from ~/.codex/config.toml. */
-async function readConfiguredModel(path) {
-    try {
-        const raw = await readFile(path, "utf8");
-        // Minimal top-level key scan: `model = "..."` (skip lines inside [tables]).
-        let inRootTable = true;
-        for (const line of raw.split(/\r?\n/)) {
-            const trimmed = line.trim();
-            if (trimmed.startsWith("#") || trimmed === "")
-                continue;
-            if (/^\[/.test(trimmed)) {
-                inRootTable = false;
-                continue;
-            }
-            if (!inRootTable)
-                continue;
-            const m = /^model\s*=\s*"([^"]+)"/.exec(trimmed);
-            if (m)
-                return m[1];
-        }
-    }
-    catch {
-        // ignore
-    }
-    return undefined;
-}
-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 usedPercent = num(map, `${prefix}-used-percent`) ?? 0;
+const WEEKLY_WINDOW_MINUTES = 7 * 24 * 60;
+// The old cache was populated from /backend-api/codex/responses headers. Keep
+// the new app-server snapshots in a separate namespace so an upgrade cannot
+// surface a model-specific response limit as the account's weekly limit.
+const CACHE_TOOL = "codex-app-server";
+function finiteNumber(value) {
+    if (typeof value !== "number" && (typeof value !== "string" || !value.trim())) {
+        return undefined;
+    }
+    const parsed = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function quotaWindow(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const usedPercent = finiteNumber(value.usedPercent);
+    if (usedPercent === undefined)
+        return undefined;
+    const resetAt = finiteNumber(value.resetsAt);
+    const now = Math.floor(Date.now() / 1000);
     return {
         usedPercent,
         remainingPercent: Math.max(0, 100 - usedPercent),
-        resetAfterSeconds: num(map, `${prefix}-reset-after-seconds`),
-        resetAt: num(map, `${prefix}-reset-at`),
-        windowMinutes: num(map, `${prefix}-window-minutes`),
+        resetAt,
+        resetAfterSeconds: resetAt === undefined ? undefined : Math.max(0, resetAt - now),
+        windowMinutes: finiteNumber(value.windowDurationMins),
     };
 }
-function parseCodexHeaders(map, extras) {
+/** Normalize Codex app-server `account/rateLimits/read` into the manager shape. */
+export function parseCodexRateLimitsResponse(response, extras = {}) {
+    const payload = response && typeof response === "object"
+        ? response
+        : {};
+    // `rateLimits` is the official backward-compatible account bucket. Do not
+    // pick a model-specific entry from rateLimitsByLimitId: e.g. Spark can have
+    // a different weekly percentage from the main Codex account limit.
+    const snapshot = payload.rateLimits && typeof payload.rateLimits === "object"
+        ? payload.rateLimits
+        : undefined;
+    const windows = [quotaWindow(snapshot?.primary), quotaWindow(snapshot?.secondary)];
+    const weekly = windows.find((window) => (window?.windowMinutes ?? 0) >= WEEKLY_WINDOW_MINUTES);
+    const credits = snapshot?.credits && typeof snapshot.credits === "object"
+        ? {
+            hasCredits: snapshot.credits.hasCredits === true,
+            balance: nonEmptyString(snapshot.credits.balance),
+            unlimited: snapshot.credits.unlimited === true,
+        }
+        : undefined;
+    const limitId = nonEmptyString(snapshot?.limitId);
+    const limitName = nonEmptyString(snapshot?.limitName);
     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"),
-        credits: {
-            hasCredits: bool(map, "x-codex-credits-has-credits") ?? false,
-            balance: str(map, "x-codex-credits-balance"),
-            unlimited: bool(map, "x-codex-credits-unlimited") ?? false,
-        },
+        plan: nonEmptyString(snapshot?.planType),
+        activeLimit: limitName ?? limitId,
+        weekly,
+        credits,
         email: extras.email,
         accountId: extras.accountId,
-        raw: Object.fromEntries(Object.entries(map).filter(([k]) => k.startsWith("x-codex-"))),
+        raw: payload,
+        ...(!weekly ? { error: "Codex rate-limit response has no weekly window" } : {}),
     };
 }
 export async function getCodexQuota(opts = {}) {
@@ -66,75 +77,69 @@ export async function getCodexQuota(opts = {}) {
     if (!authInfo.accessToken) {
         return emptyQuota("unknown", "codex auth.json missing access_token");
     }
-    const fp = fingerprintKey(["codex", authInfo.identityFingerprint ?? "unknown"]);
-    const file = cacheFile("codex", fp, opts.cacheDir);
+    const fp = fingerprintKey([CACHE_TOOL, authInfo.identityFingerprint ?? "unknown"]);
+    const file = cacheFile(CACHE_TOOL, fp, opts.cacheDir);
     if (!opts.forceRefresh && ttl > 0) {
         const cached = await readCache(file);
         if (isFresh(cached, ttl) && cached) {
             return { ...cached.value, source: "cached" };
         }
     }
-    const model = opts.model ??
-        (await readConfiguredModel(opts.codexConfigPath ?? DEFAULT_CODEX_CONFIG)) ??
-        "gpt-5";
-    const body = JSON.stringify({
-        model,
-        instructions: "Reply with exactly one character.",
-        input: [
-            { type: "message", role: "user", content: [{ type: "input_text", text: "." }] },
-        ],
-        stream: true,
-        store: false,
-    });
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    let res;
+    let response;
     try {
-        res = await fetch(RESPONSES_URL, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${authInfo.accessToken}`,
-                "Content-Type": "application/json",
-                "OpenAI-Beta": "responses=experimental",
-                ...(authInfo.accountId ? { "chatgpt-account-id": authInfo.accountId } : {}),
-            },
-            body,
-            signal: controller.signal,
+        response = await (opts.rateLimitsReader ?? readCodexRateLimits)({
+            codexAuthPath,
+            timeoutMs,
         });
     }
-    catch (err) {
-        clearTimeout(timer);
-        return await fallbackFromCache(file, ttl, err?.message ?? String(err));
-    }
-    // Abort the body stream immediately once headers are in; they're all we need.
-    try {
-        await res.body?.cancel();
-    }
-    catch {
-        // ignore
-    }
-    clearTimeout(timer);
-    const map = headersToMap(res.headers);
-    if (res.status === 401 || res.status === 403) {
-        return await fallbackFromCache(file, ttl, `auth failed: HTTP ${res.status}`);
+    catch (error) {
+        return fallbackFromCache(file, ttl, errorMessage(error));
     }
-    const parsed = parseCodexHeaders(map, {
+    const parsed = parseCodexRateLimitsResponse(response, {
         email: authInfo.email,
         accountId: authInfo.accountId,
     });
-    const now = Math.floor(Date.now() / 1000);
+    if (!parsed.weekly) {
+        return fallbackFromCache(file, ttl, parsed.error ?? "Codex weekly quota unavailable");
+    }
     const fresh = {
         tool: "codex",
-        fetchedAt: now,
+        fetchedAt: Math.floor(Date.now() / 1000),
         source: "fresh",
         ...parsed,
     };
-    // Only persist if we actually got rate-limit headers — otherwise the upstream was unhealthy.
-    if (Object.keys(fresh.raw ?? {}).length > 0) {
-        await writeCache(file, fresh);
-        return fresh;
+    await writeCache(file, fresh);
+    return fresh;
+}
+async function readCodexRateLimits(options) {
+    if (basename(options.codexAuthPath) !== "auth.json") {
+        throw new Error(`Codex app-server quota requires an active auth.json path; got ${options.codexAuthPath}`);
+    }
+    const transport = new CodexAppServerTransport({
+        env: { CODEX_HOME: dirname(options.codexAuthPath) },
+        ignoreCodexApiKey: true,
+    });
+    try {
+        return await withTimeout(transport.request("account/rateLimits/read"), options.timeoutMs, "Codex account/rateLimits/read timed out");
+    }
+    finally {
+        await transport.close();
+    }
+}
+async function withTimeout(promise, timeoutMs, message) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
     }
-    return await fallbackFromCache(file, ttl, `no x-codex-* headers on HTTP ${res.status}`);
 }
 async function fallbackFromCache(file, ttl, error) {
     const cached = await readCache(file);
@@ -149,34 +154,37 @@ async function fallbackFromCache(file, ttl, error) {
 }
 /**
  * Read the on-disk quota cache for a given codex auth.json without triggering
- * any network call. Returns whatever snapshot was last written (regardless of
- * age) or `null` if nothing has been cached for this identity yet. Used by the
- * daemon's `list_accounts` handler to surface "last known" quota for inactive
- * accounts so the web UI can restore them across page refreshes.
+ * any network call. Only app-server snapshots are considered; legacy caches
+ * from response headers are intentionally ignored.
  */
 export async function readCachedCodexQuota(codexAuthPath, opts = {}) {
     try {
         const authInfo = await parseAuthFile(codexAuthPath);
         if (!authInfo.identityFingerprint)
             return null;
-        const fp = fingerprintKey(["codex", authInfo.identityFingerprint]);
-        const file = cacheFile("codex", fp, opts.cacheDir);
+        const fp = fingerprintKey([CACHE_TOOL, authInfo.identityFingerprint]);
+        const file = cacheFile(CACHE_TOOL, fp, opts.cacheDir);
         const entry = await readCache(file);
         if (!entry)
             return null;
-        return { ...entry.value, source: "cached", fetchedAt: entry.fetchedAt };
+        return {
+            ...entry.value,
+            source: "cached",
+            fetchedAt: entry.fetchedAt,
+        };
     }
     catch {
         return null;
     }
 }
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 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,8 +37,7 @@ export interface CodexQuota {
     tool: "codex";
     plan?: string;
     activeLimit?: string;
-    fiveHour: QuotaWindow;
-    weekly: QuotaWindow;
+    weekly?: QuotaWindow;
     credits?: {
         hasCredits: boolean;
         balance?: string;
@@ -48,7 +47,7 @@ export interface CodexQuota {
     source: QuotaSource;
     email?: string;
     accountId?: string;
-    raw?: Record<string, string>;
+    raw?: Record<string, unknown>;
     error?: string;
 }
 export interface ClaudeQuota {

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.5",
   "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.5"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
     "tsx": "^4.20.6",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "8081263"
+  "gitCommitId": "702c7c4"
 }