@jingyi0605/codingns 0.8.0 → 0.8.5

package/node_modules/@codingns/session-sync-core/dist/runtime/kimi-runtime.js

@@ -0,0 +1,911 @@
+import { spawn } from "node:child_process";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { buildKimiSessionRawStoreRef, findKimiWorkDirRecordByPath, readKimiWorkDirRecords } from "../kimi-shared.js";
+import { extractTextBlocks, messageIdFromRawRef, nextTimestamp, safeDate } from "../providers/utils.js";
+import { buildKimiMessageRawRef, extractKimiDisplayTextSegments, looksLikeKimiMessagePayload, normalizeKimiMessageRecord, readKimiFirstNonEmptyString, readKimiFirstPresentValue } from "../kimi-message-normalizer.js";
+const INTERRUPT_KILL_TIMEOUT_MS = 1_500;
+const READY_SIGNAL_TIMEOUT_MS = 700;
+const KIMI_START_BINDING_RESOLVE_TIMEOUT_MS = 10_000;
+const KIMI_START_BINDING_RESOLVE_POLL_MS = 100;
+export class KimiRuntimeAdapter {
+    options;
+    providerId = "kimi";
+    commandPath;
+    baseArgs;
+    spawnFactory;
+    cliSyntax;
+    cliProbeTimeoutMs;
+    cliSyntaxPromise = null;
+    constructor(options) {
+        this.options = options;
+        this.commandPath = options.commandPath?.trim() || "kimi";
+        this.baseArgs = options.baseArgs ?? [];
+        this.spawnFactory = options.spawnFactory ?? spawn;
+        this.cliSyntax = options.cliSyntax ?? "auto";
+        this.cliProbeTimeoutMs = options.cliProbeTimeoutMs ?? 1_500;
+    }
+    async startSession(request, sink) {
+        const pendingBinding = buildPendingKimiBinding(request.sessionId);
+        const startBindingProbe = this.captureStartBindingProbe(request.workspacePath);
+        sink.updateSessionBinding(pendingBinding);
+        return this.launchWithFallback({
+            request,
+            sink,
+            mode: "start",
+            sessionId: pendingBinding.providerSessionId,
+            rawStoreRef: pendingBinding.rawStoreRef,
+            startBindingProbe
+        });
+    }
+    async continueSession(request, sink) {
+        const sessionId = request.providerSessionId?.trim();
+        if (!sessionId) {
+            throw new Error("PROVIDER_SESSION_ID_REQUIRED");
+        }
+        const rawStoreRef = request.rawStoreRef ?? buildKimiSessionRawStoreRef(sessionId);
+        sink.updateSessionBinding({
+            providerSessionId: sessionId,
+            rawStoreRef
+        });
+        return this.launchWithFallback({
+            request,
+            sink,
+            mode: "continue",
+            sessionId,
+            rawStoreRef,
+            startBindingProbe: null
+        });
+    }
+    async launchWithFallback(context) {
+        const cliSyntax = await this.resolveCliSyntax();
+        const commandAttempt = this.launchTransport(context, "command", cliSyntax);
+        try {
+            await commandAttempt.ready;
+            this.scheduleBindingResolution(context, commandAttempt);
+            return commandAttempt.launch;
+        }
+        catch (commandError) {
+            commandAttempt.launch.completed.catch(() => {
+                return;
+            });
+            const commandDetail = extractErrorDetail(await commandAttempt.launch.completed.then(() => null).catch((error) => error));
+            throw new Error(`KIMI_RUNTIME_FALLBACK_FAILED: wire=disabled; command=${commandDetail}; cause=${extractErrorDetail(commandError)}`);
+        }
+    }
+    launchTransport(context, transport, cliSyntax) {
+        const args = [
+            ...this.baseArgs,
+            ...buildKimiRuntimeArgs(transport, context.mode, context.sessionId, context.request, cliSyntax)
+        ];
+        const proc = this.spawnFactory(this.commandPath, args, {
+            cwd: context.request.workspacePath,
+            env: buildKimiSpawnEnv(),
+            shell: shouldSpawnViaShell(this.commandPath),
+            windowsHide: true,
+            stdio: ["pipe", "pipe", "pipe"]
+        });
+        let sequence = Math.max(0, context.request.sequenceBase ?? 0);
+        let lineNumber = 0;
+        let interrupted = false;
+        let settled = false;
+        let activeSessionId = context.sessionId;
+        let activeRawStoreRef = context.rawStoreRef;
+        let stderrBuffer = "";
+        let lineChain = Promise.resolve();
+        let stdinClosed = false;
+        let writeChain = Promise.resolve();
+        let sawStdoutEvent = false;
+        let readySettled = false;
+        let plainTextBuffer = [];
+        let plainTextStartLineNumber = 0;
+        const recentMessageSignatures = [];
+        let readyTimer = null;
+        let resolveReady = null;
+        let rejectReady = null;
+        const updateActiveBinding = (binding) => {
+            if (!binding.providerSessionId.trim()
+                || (binding.providerSessionId === activeSessionId
+                    && binding.rawStoreRef === activeRawStoreRef)) {
+                return;
+            }
+            activeSessionId = binding.providerSessionId;
+            activeRawStoreRef = binding.rawStoreRef;
+            context.sink.updateSessionBinding(binding);
+            launch.providerSessionId = binding.providerSessionId;
+            launch.rawStoreRef = binding.rawStoreRef;
+        };
+        const enqueuePromptWrite = (options, closeAfterWrite = false) => {
+            writeChain = writeChain.then(() => this.writePromptPayload(proc, options, transport, closeAfterWrite));
+            return writeChain;
+        };
+        const canSubmitInRunInput = () => !interrupted &&
+            !settled &&
+            !proc.killed &&
+            !stdinClosed &&
+            !proc.stdin.destroyed &&
+            !proc.stdin.writableEnded &&
+            proc.stdin.writable;
+        const ready = new Promise((resolve, reject) => {
+            resolveReady = resolve;
+            rejectReady = (error) => reject(error);
+        });
+        const settleReady = (error) => {
+            if (readySettled) {
+                return;
+            }
+            readySettled = true;
+            if (readyTimer) {
+                clearTimeout(readyTimer);
+            }
+            if (error) {
+                rejectReady?.(error);
+            }
+            else {
+                resolveReady?.();
+            }
+        };
+        readyTimer = setTimeout(() => {
+            settleReady();
+        }, READY_SIGNAL_TIMEOUT_MS);
+        const completed = new Promise((resolve, reject) => {
+            const settle = (callback) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                callback();
+            };
+            const onStructuredEvent = async (event) => {
+                if (event.providerSessionId?.trim() && event.providerSessionId !== activeSessionId) {
+                    updateActiveBinding({
+                        providerSessionId: event.providerSessionId,
+                        rawStoreRef: event.rawStoreRef ?? buildKimiSessionRawStoreRef(event.providerSessionId)
+                    });
+                }
+                await context.sink.emit({
+                    ...event,
+                    providerSessionId: activeSessionId,
+                    rawStoreRef: activeRawStoreRef
+                });
+            };
+            const emitRuntimeEvent = async (event) => {
+                if (event.type === "message" && event.message) {
+                    if (shouldSkipEquivalentRecentKimiRuntimeMessage(recentMessageSignatures, event.message)) {
+                        return;
+                    }
+                    rememberKimiRuntimeMessage(recentMessageSignatures, event.message);
+                }
+                await onStructuredEvent(event);
+            };
+            const handleJsonPayload = async (payload) => {
+                const mapped = mapKimiWirePayload(payload, {
+                    sessionId: activeSessionId,
+                    rawStoreRef: activeRawStoreRef,
+                    sequence,
+                    lineNumber
+                });
+                if (mapped.providerSessionId && mapped.providerSessionId !== activeSessionId) {
+                    updateActiveBinding({
+                        providerSessionId: mapped.providerSessionId,
+                        rawStoreRef: buildKimiSessionRawStoreRef(mapped.providerSessionId)
+                    });
+                }
+                for (const event of mapped.events) {
+                    if (event.type === "message" && event.message) {
+                        sequence = event.message.sequence;
+                    }
+                    await emitRuntimeEvent(event);
+                }
+            };
+            const flushBufferedPlainText = async () => {
+                if (plainTextBuffer.length === 0) {
+                    return;
+                }
+                const startLineNumber = plainTextStartLineNumber || lineNumber;
+                const contentBlocks = extractKimiDisplayTextSegments(plainTextBuffer.join("\n"));
+                plainTextBuffer = [];
+                plainTextStartLineNumber = 0;
+                for (const [contentIndex, content] of contentBlocks.entries()) {
+                    const nextSequence = sequence + 1;
+                    sequence = nextSequence;
+                    const message = createTextMessage({
+                        sessionId: activeSessionId,
+                        rawStoreRef: activeRawStoreRef,
+                        sequence: nextSequence,
+                        lineNumber: startLineNumber,
+                        role: "assistant",
+                        kind: "text",
+                        content,
+                        timestamp: nextTimestamp(),
+                        rawEventRef: buildKimiMessageRawRef(activeSessionId, "wire", startLineNumber, contentBlocks.length > 1 ? contentIndex : undefined)
+                    });
+                    await emitRuntimeEvent({
+                        type: "message",
+                        message,
+                        status: "running",
+                        detail: "wire line",
+                        rawEventRef: message.rawRef
+                    });
+                }
+            };
+            const handleStdoutLine = (line) => {
+                lineNumber += 1;
+                const trimmed = line.trim();
+                const payload = trimmed ? parseJsonObject(trimmed) : null;
+                if (payload) {
+                    sawStdoutEvent = true;
+                    settleReady();
+                    return flushBufferedPlainText().then(() => handleJsonPayload(payload));
+                }
+                if (!trimmed) {
+                    if (plainTextBuffer.length > 0) {
+                        plainTextBuffer.push("");
+                    }
+                    return Promise.resolve();
+                }
+                sawStdoutEvent = true;
+                settleReady();
+                if (plainTextBuffer.length === 0) {
+                    plainTextStartLineNumber = lineNumber;
+                }
+                plainTextBuffer.push(line);
+                if (trimmed.toLowerCase() === "turnend") {
+                    return flushBufferedPlainText();
+                }
+                return Promise.resolve();
+            };
+            const stdoutReader = createInterface({ input: proc.stdout });
+            stdoutReader.on("line", (line) => {
+                lineChain = lineChain.then(() => handleStdoutLine(line));
+            });
+            proc.stderr.setEncoding("utf8");
+            proc.stderr.on("data", (chunk) => {
+                stderrBuffer = `${stderrBuffer}${chunk}`.trim();
+            });
+            proc.once("error", (error) => {
+                if (transport === "wire") {
+                    settleReady(toWireUnavailableError(error));
+                }
+                else {
+                    settleReady(error instanceof Error ? error : new Error("KIMI_RUNTIME_FAILED"));
+                }
+                settle(() => {
+                    reject(error);
+                });
+            });
+            proc.once("close", (code, signal) => {
+                stdinClosed = true;
+                if (!sawStdoutEvent && !interrupted && code !== 0) {
+                    if (transport === "wire") {
+                        settleReady(toWireUnavailableError(new Error(stderrBuffer ||
+                            `Kimi wire exited with code=${String(code ?? "null")} signal=${String(signal ?? "null")}`)));
+                    }
+                    else {
+                        settleReady(new Error(stderrBuffer ||
+                            `Kimi command exited with code=${String(code ?? "null")} signal=${String(signal ?? "null")}`));
+                    }
+                }
+                else {
+                    settleReady();
+                }
+                void lineChain
+                    .then(async () => {
+                    await flushBufferedPlainText();
+                    if (interrupted) {
+                        settle(() => {
+                            resolve();
+                        });
+                        return;
+                    }
+                    if (code === 0) {
+                        settle(() => {
+                            resolve();
+                        });
+                        return;
+                    }
+                    const detail = stderrBuffer ||
+                        `Kimi ${transport} exited with code=${String(code ?? "null")} signal=${String(signal ?? "null")}`;
+                    settle(() => {
+                        reject(new Error(detail));
+                    });
+                })
+                    .catch((error) => {
+                    settle(() => {
+                        reject(error instanceof Error ? error : new Error("KIMI_WIRE_RUNTIME_FAILED"));
+                    });
+                });
+            });
+            enqueuePromptWrite(context.request.options, transport === "command").catch((error) => {
+                settle(() => {
+                    reject(error);
+                });
+            });
+        });
+        const submitDuringRun = async (options) => {
+            if (transport === "command" || !canSubmitInRunInput()) {
+                throw new Error("IN_RUN_INPUT_NOT_SUPPORTED");
+            }
+            return enqueuePromptWrite(options).catch((error) => {
+                throw mapInRunSubmitError(error);
+            });
+        };
+        const launch = {
+            providerSessionId: context.sessionId,
+            rawStoreRef: context.rawStoreRef,
+            interrupt: async () => {
+                interrupted = true;
+                if (proc.killed) {
+                    return;
+                }
+                proc.kill("SIGINT");
+                await new Promise((resolve) => {
+                    const timeout = setTimeout(() => {
+                        if (!proc.killed) {
+                            proc.kill("SIGKILL");
+                        }
+                        resolve();
+                    }, INTERRUPT_KILL_TIMEOUT_MS);
+                    proc.once("close", () => {
+                        clearTimeout(timeout);
+                        resolve();
+                    });
+                });
+            },
+            isAlive: () => !proc.killed,
+            submitDuringRun: transport === "command" ? undefined : submitDuringRun,
+            completed
+        };
+        return {
+            transport,
+            launch,
+            ready,
+            updateBinding: updateActiveBinding
+        };
+    }
+    scheduleBindingResolution(context, attempt) {
+        if (context.mode !== "start" || !isPendingKimiBinding(context.sessionId)) {
+            return;
+        }
+        void Promise.race([
+            this.resolveStartedSessionBinding(context.request.workspacePath, context.startBindingProbe),
+            attempt.launch.completed.then(() => null)
+        ])
+            .then(async (binding) => {
+            if (!binding) {
+                return;
+            }
+            attempt.updateBinding(binding);
+            await context.sink.emit({
+                type: "session_created",
+                status: "starting",
+                providerSessionId: binding.providerSessionId,
+                rawStoreRef: binding.rawStoreRef,
+                detail: "Kimi session binding resolved"
+            });
+        })
+            .catch(() => {
+            return;
+        });
+    }
+    async resolveCliSyntax() {
+        if (this.cliSyntax !== "auto") {
+            return this.cliSyntax;
+        }
+        if (!this.cliSyntaxPromise) {
+            // 先探测本地 CLI 的参数风格，避免新版/旧版参数互相打架。
+            this.cliSyntaxPromise = detectKimiCliSyntax({
+                commandPath: this.commandPath,
+                baseArgs: this.baseArgs,
+                spawnFactory: this.spawnFactory,
+                timeoutMs: this.cliProbeTimeoutMs
+            }).catch(() => "modern");
+        }
+        return this.cliSyntaxPromise;
+    }
+    async resolveStartedSessionBinding(workspacePath, startBindingProbe) {
+        const startedAtMs = Date.now();
+        const initialLastSessionId = startBindingProbe?.lastSessionId ?? null;
+        const workDirHash = startBindingProbe?.workDirHash ?? null;
+        while (Date.now() - startedAtMs < KIMI_START_BINDING_RESOLVE_TIMEOUT_MS) {
+            const workDirs = readKimiWorkDirRecords(this.options.homeDir);
+            const activeWorkDir = findKimiWorkDirRecordByPath(workDirs, workspacePath);
+            const candidateSessionId = this.findResolvedSessionIdFromWorkDir(activeWorkDir?.lastSessionId ?? null, initialLastSessionId)
+                ?? this.findLatestSessionIdForWorkspace(activeWorkDir?.hash ?? workDirHash, startedAtMs, initialLastSessionId);
+            if (candidateSessionId) {
+                return {
+                    providerSessionId: candidateSessionId,
+                    rawStoreRef: buildKimiSessionRawStoreRef(candidateSessionId)
+                };
+            }
+            await waitForKimiBindingResolvePoll();
+        }
+        return null;
+    }
+    captureStartBindingProbe(workspacePath) {
+        const workDirs = readKimiWorkDirRecords(this.options.homeDir);
+        const workDir = findKimiWorkDirRecordByPath(workDirs, workspacePath);
+        return {
+            workDirHash: workDir?.hash ?? null,
+            lastSessionId: workDir?.lastSessionId ?? null
+        };
+    }
+    findResolvedSessionIdFromWorkDir(candidateSessionId, initialLastSessionId) {
+        const normalizedCandidate = candidateSessionId?.trim();
+        if (!normalizedCandidate) {
+            return null;
+        }
+        if (initialLastSessionId && normalizedCandidate === initialLastSessionId) {
+            return null;
+        }
+        return normalizedCandidate;
+    }
+    findLatestSessionIdForWorkspace(workDirHash, startedAtMs, initialLastSessionId) {
+        if (!workDirHash?.trim()) {
+            return null;
+        }
+        const workspaceSessionsDir = join(this.options.homeDir, "sessions", workDirHash);
+        if (!existsSync(workspaceSessionsDir)) {
+            return null;
+        }
+        let bestCandidate = null;
+        const entries = readdirSync(workspaceSessionsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            if (initialLastSessionId && entry.name === initialLastSessionId) {
+                continue;
+            }
+            const sessionDir = join(workspaceSessionsDir, entry.name);
+            const mtimeMs = readKimiSessionDirectoryMtime(sessionDir);
+            if (mtimeMs < startedAtMs - 1_000) {
+                continue;
+            }
+            if (!bestCandidate || mtimeMs > bestCandidate.mtimeMs) {
+                bestCandidate = {
+                    sessionId: entry.name,
+                    mtimeMs
+                };
+            }
+        }
+        return bestCandidate?.sessionId ?? null;
+    }
+    async writePrompt(proc, request) {
+        return this.writePromptPayload(proc, request.options, "command");
+    }
+    async writePromptPayload(proc, options, transport, closeAfterWrite = false) {
+        const prompt = options.providerPrompt?.trim() || options.content.trim();
+        if (!prompt) {
+            if (transport === "command" && closeAfterWrite) {
+                await this.closeCommandInput(proc);
+            }
+            return;
+        }
+        const payload = transport === "command"
+            ? buildCommandInputPayloadFromOptions(prompt)
+            : buildPromptPayloadFromOptions(options, prompt);
+        await this.writeWirePayload(proc, payload);
+        if (transport === "command" && closeAfterWrite) {
+            await this.closeCommandInput(proc);
+        }
+    }
+    async writeWirePayload(proc, payload) {
+        await new Promise((resolve, reject) => {
+            proc.stdin.write(`${JSON.stringify(payload)}\n`, (error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    async closeCommandInput(proc) {
+        if (proc.stdin.destroyed || proc.stdin.writableEnded) {
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            try {
+                proc.stdin.end();
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+}
+function buildPromptPayloadFromOptions(options, prompt) {
+    return {
+        type: "prompt.submit",
+        content: prompt,
+        client_request_id: options.clientRequestId,
+        permission_mode: options.permissionMode,
+        model: options.model,
+        reasoning_level: options.reasoningLevel,
+        attachments: options.attachments.map((attachment) => ({
+            file_path: attachment.filePath,
+            file_name: attachment.fileName,
+            mime_type: attachment.mimeType,
+            file_size: attachment.fileSize
+        }))
+    };
+}
+function buildKimiRuntimeArgs(transport, mode, sessionId, request, cliSyntax) {
+    if (cliSyntax === "modern") {
+        return buildModernKimiRuntimeArgs(transport, mode, sessionId, request);
+    }
+    return buildLegacyKimiRuntimeArgs(transport, mode, sessionId, request);
+}
+function buildModernKimiRuntimeArgs(transport, mode, sessionId, request) {
+    if (transport === "wire") {
+        const args = ["--wire"];
+        if (mode === "continue") {
+            args.push("--session", sessionId);
+        }
+        args.push("--work-dir", request.workspacePath);
+        if (request.options.model) {
+            args.push("--model", request.options.model);
+        }
+        return args;
+    }
+    const args = ["--print", "--output-format", "stream-json", "--input-format", "stream-json"];
+    if (mode === "continue") {
+        args.push("--session", sessionId);
+    }
+    args.push("--work-dir", request.workspacePath);
+    if (request.options.model) {
+        args.push("--model", request.options.model);
+    }
+    return args;
+}
+function buildLegacyKimiRuntimeArgs(transport, mode, sessionId, request) {
+    if (transport === "wire") {
+        const args = ["wire", "--output-format", "stream-json"];
+        if (mode === "continue") {
+            args.push("--resume", sessionId);
+        }
+        else {
+            args.push("--new-session");
+        }
+        args.push("--cwd", request.workspacePath);
+        if (request.options.model) {
+            args.push("--model", request.options.model);
+        }
+        return args;
+    }
+    const args = ["--print", "--output-format", "stream-json", "--input-format", "stream-json"];
+    if (mode === "continue") {
+        args.push("--resume", sessionId);
+    }
+    args.push("--cwd", request.workspacePath);
+    if (request.options.model) {
+        args.push("--model", request.options.model);
+    }
+    return args;
+}
+function parseJsonObject(line) {
+    try {
+        const parsed = JSON.parse(line);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function mapKimiWirePayload(payload, context) {
+    const events = [];
+    const wireType = (readKimiFirstNonEmptyString(payload, [
+        ["type"],
+        ["event"],
+        ["kind"],
+        ["message", "type"],
+        ["message", "payload", "type"],
+        ["payload", "type"]
+    ]) ?? "").trim().toLowerCase();
+    const providerSessionId = readKimiFirstNonEmptyString(payload, [
+        ["sessionId"],
+        ["session_id"],
+        ["session", "id"]
+    ]) ?? null;
+    const timestamp = resolveEventTimestamp(payload);
+    const resolvedSessionId = providerSessionId ?? context.sessionId;
+    const resolvedRawStoreRef = providerSessionId
+        ? buildKimiSessionRawStoreRef(providerSessionId)
+        : context.rawStoreRef;
+    const rawEventRef = buildKimiMessageRawRef(resolvedSessionId, "wire", context.lineNumber);
+    if (wireType.includes("session") && wireType.includes("created")) {
+        events.push({
+            type: "session_created",
+            status: "starting",
+            timestamp,
+            detail: "Kimi wire session created",
+            rawEventRef,
+            providerSessionId: providerSessionId ?? undefined
+        });
+    }
+    if (wireType.includes("running") || wireType.includes("progress")) {
+        events.push({
+            type: "status",
+            status: "running",
+            timestamp,
+            detail: extractTextBlocks(payload).trim() || "Kimi wire running",
+            rawEventRef,
+            providerSessionId: providerSessionId ?? undefined
+        });
+    }
+    if (wireType.includes("question") || wireType.includes("prompt") || wireType.includes("request")) {
+        events.push({
+            type: "status",
+            status: "running",
+            timestamp,
+            detail: extractTextBlocks(payload).trim() || "Kimi wire awaiting runtime guidance",
+            rawEventRef,
+            providerSessionId: providerSessionId ?? undefined
+        });
+    }
+    const maybeError = readKimiFirstNonEmptyString(payload, [["error"], ["detail"], ["message"]]);
+    if (wireType.includes("error") || wireType.includes("failed")) {
+        events.push({
+            type: "error",
+            status: "failed",
+            timestamp,
+            detail: maybeError || "Kimi wire failed",
+            errorCode: normalizeErrorCode(payload),
+            rawEventRef,
+            providerSessionId: providerSessionId ?? undefined
+        });
+        return {
+            providerSessionId,
+            events
+        };
+    }
+    // Kimi 的 wire 完成标记经常早于本地历史真正落盘，这里不直接发 completed，
+    // 改由进程 completed Promise 作为终态来源，避免前端过早显示“已结束”。
+    const normalizedMessages = normalizeKimiWireMessages(payload, wireType, {
+        sessionId: resolvedSessionId,
+        rawStoreRef: resolvedRawStoreRef,
+        sequence: context.sequence,
+        lineNumber: context.lineNumber,
+        timestamp
+    });
+    for (const normalizedMessage of normalizedMessages) {
+        events.push({
+            type: "message",
+            message: normalizedMessage,
+            status: "running",
+            timestamp,
+            detail: null,
+            rawEventRef: normalizedMessage.rawRef,
+            providerSessionId: providerSessionId ?? undefined
+        });
+    }
+    return {
+        providerSessionId,
+        events
+    };
+}
+function normalizeKimiWireMessages(payload, wireType, input) {
+    if (!looksLikeKimiMessagePayload(payload, wireType)) {
+        return [];
+    }
+    const normalizedParts = normalizeKimiMessageRecord(payload);
+    return normalizedParts.map((part, index) => createTextMessage({
+        sessionId: input.sessionId,
+        rawStoreRef: input.rawStoreRef,
+        sequence: input.sequence + index + 1,
+        lineNumber: input.lineNumber,
+        role: part.role,
+        kind: part.kind,
+        content: part.content,
+        timestamp: input.timestamp,
+        rawEventRef: buildKimiMessageRawRef(input.sessionId, "wire", input.lineNumber, part.partIndex ?? undefined),
+        toolCall: part.toolCall
+    }));
+}
+function createTextMessage(input) {
+    return {
+        messageId: messageIdFromRawRef(input.rawEventRef),
+        provider: "kimi",
+        providerSessionId: input.sessionId,
+        role: input.role,
+        kind: input.kind,
+        content: input.content,
+        toolCall: input.toolCall ?? null,
+        timestamp: input.timestamp,
+        sequence: input.sequence,
+        rawRef: input.rawEventRef
+    };
+}
+function resolveEventTimestamp(payload) {
+    const raw = readKimiFirstPresentValue(payload, [
+        ["timestamp"],
+        ["created_at"],
+        ["createdAt"],
+        ["time"],
+        ["event", "timestamp"]
+    ]);
+    return safeDate(raw, nextTimestamp()) || nextTimestamp();
+}
+function normalizeErrorCode(payload) {
+    const code = readKimiFirstNonEmptyString(payload, [["error_code"], ["code"], ["error", "code"]]);
+    return code?.trim().toUpperCase().replace(/[^A-Z0-9_]+/g, "_") || "KIMI_WIRE_ERROR";
+}
+function toWireUnavailableError(error) {
+    return new Error(`KIMI_WIRE_MODE_UNAVAILABLE: ${extractErrorDetail(error)}`);
+}
+function isWireUnavailableError(error) {
+    return error instanceof Error && error.message.startsWith("KIMI_WIRE_MODE_UNAVAILABLE:");
+}
+function extractErrorDetail(error) {
+    if (error instanceof Error) {
+        return error.message.trim() || "unknown error";
+    }
+    if (typeof error === "string") {
+        return error.trim() || "unknown error";
+    }
+    return "unknown error";
+}
+function mapInRunSubmitError(error) {
+    if (error instanceof Error && error.message === "IN_RUN_INPUT_NOT_SUPPORTED") {
+        return error;
+    }
+    if (isClosedStdinError(error)) {
+        return new Error("IN_RUN_INPUT_NOT_SUPPORTED");
+    }
+    return error instanceof Error ? error : new Error("IN_RUN_INPUT_NOT_SUPPORTED");
+}
+function isClosedStdinError(error) {
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+    const code = error.code;
+    return (code === "EPIPE" ||
+        code === "ECONNRESET" ||
+        code === "ERR_STREAM_DESTROYED" ||
+        code === "ERR_STREAM_WRITE_AFTER_END");
+}
+function shouldSkipEquivalentRecentKimiRuntimeMessage(recentMessages, message) {
+    if (message.kind !== "text" && message.kind !== "thinking") {
+        return false;
+    }
+    const comparableContent = normalizeComparableKimiRuntimeMessageContent(message.content);
+    if (!comparableContent) {
+        return false;
+    }
+    return recentMessages.some((item) => item.role === message.role
+        && item.kind === message.kind
+        && item.comparableContent === comparableContent);
+}
+function rememberKimiRuntimeMessage(recentMessages, message) {
+    const comparableContent = normalizeComparableKimiRuntimeMessageContent(message.content);
+    if (!comparableContent) {
+        return;
+    }
+    recentMessages.push({
+        role: message.role,
+        kind: message.kind,
+        comparableContent
+    });
+    if (recentMessages.length > 8) {
+        recentMessages.splice(0, recentMessages.length - 8);
+    }
+}
+function normalizeComparableKimiRuntimeMessageContent(content) {
+    const cleaned = extractKimiDisplayTextSegments(content).join("\n\n") || content;
+    return cleaned
+        .replace(/\r\n/g, "\n")
+        .trim()
+        .replace(/\s+/g, " ");
+}
+function shouldSpawnViaShell(commandPath) {
+    return /\.(cmd|bat|ps1)$/i.test(commandPath);
+}
+function buildKimiSpawnEnv() {
+    return {
+        ...process.env,
+        PYTHONIOENCODING: "utf-8",
+        PYTHONUTF8: "1"
+    };
+}
+function buildPendingKimiBinding(sessionId) {
+    const pendingValue = `pending://kimi/${sessionId}`;
+    return {
+        providerSessionId: pendingValue,
+        rawStoreRef: pendingValue
+    };
+}
+function buildCommandInputPayloadFromOptions(prompt) {
+    return {
+        role: "user",
+        content: [
+            {
+                type: "text",
+                text: prompt
+            }
+        ]
+    };
+}
+function isPendingKimiBinding(value) {
+    return value.trim().toLowerCase().startsWith("pending://kimi/");
+}
+function readKimiSessionDirectoryMtime(sessionDir) {
+    let mtimeMs = 0;
+    for (const fileName of ["state.json", "context.jsonl", "wire.jsonl"]) {
+        const filePath = join(sessionDir, fileName);
+        if (!existsSync(filePath)) {
+            continue;
+        }
+        mtimeMs = Math.max(mtimeMs, statSync(filePath).mtimeMs);
+    }
+    return mtimeMs;
+}
+function waitForKimiBindingResolvePoll() {
+    return new Promise((resolve) => {
+        setTimeout(resolve, KIMI_START_BINDING_RESOLVE_POLL_MS);
+    });
+}
+async function detectKimiCliSyntax(input) {
+    const helpOutput = await captureKimiCliOutput(input, ["--help"]);
+    if (looksLikeModernKimiHelp(helpOutput)) {
+        return "modern";
+    }
+    if (looksLikeLegacyKimiHelp(helpOutput)) {
+        return "legacy";
+    }
+    return "modern";
+}
+async function captureKimiCliOutput(input, probeArgs) {
+    return new Promise((resolve) => {
+        const proc = input.spawnFactory(input.commandPath, [...input.baseArgs, ...probeArgs], {
+            shell: shouldSpawnViaShell(input.commandPath),
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+        let settled = false;
+        let stdoutBuffer = "";
+        let stderrBuffer = "";
+        const finalize = (value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            resolve(value);
+        };
+        const timeout = setTimeout(() => {
+            if (!proc.killed) {
+                proc.kill("SIGTERM");
+            }
+            finalize(`${stdoutBuffer}\n${stderrBuffer}`.trim());
+        }, Math.max(200, input.timeoutMs));
+        proc.stdout.setEncoding("utf8");
+        proc.stdout.on("data", (chunk) => {
+            stdoutBuffer += chunk;
+        });
+        proc.stderr.setEncoding("utf8");
+        proc.stderr.on("data", (chunk) => {
+            stderrBuffer += chunk;
+        });
+        proc.once("error", () => {
+            finalize(`${stdoutBuffer}\n${stderrBuffer}`.trim());
+        });
+        proc.once("close", () => {
+            finalize(`${stdoutBuffer}\n${stderrBuffer}`.trim());
+        });
+    });
+}
+function looksLikeModernKimiHelp(output) {
+    const normalized = output.toLowerCase();
+    return normalized.includes("--wire") || normalized.includes("--work-dir");
+}
+function looksLikeLegacyKimiHelp(output) {
+    const normalized = output.toLowerCase();
+    return normalized.includes("--cwd") || normalized.includes("no such command 'wire'");
+}
+//# sourceMappingURL=kimi-runtime.js.map