@jingyi0605/codingns 0.7.4 → 0.8.0

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

@@ -1,911 +0,0 @@
-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