@jingyi0605/codingns 0.7.3 → 0.8.0

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

@@ -1,659 +0,0 @@
-import { ensureText, extractTextBlocks } from "./providers/utils.js";
-import { buildApplyPatchFromStructuredFileTool } from "./patch-builder.js";
-const KIMI_CONTROL_TEXT_LINES = new Set([
-    "turnbegin",
-    "turnend",
-    "stepbegin",
-    "stepend",
-    "stepinterrupted",
-    "contentpart",
-    "statusupdate",
-    "metadata",
-    "_usage",
-    "_checkpoint"
-]);
-const KIMI_STATUS_TOKEN_PATTERN = /^chatcmpl[-_a-z0-9]+$/i;
-export function buildKimiMessageRawRef(sessionId, source, lineNumber, partIndex) {
-    const suffix = partIndex === undefined ? "" : `&part=${partIndex}`;
-    return `kimi://session/${encodeURIComponent(sessionId)}/${source}#line=${lineNumber}${suffix}`;
-}
-export function readKimiPath(value, path) {
-    let current = value;
-    for (const key of path) {
-        if (!current || typeof current !== "object") {
-            return undefined;
-        }
-        current = current[key];
-    }
-    return current;
-}
-export function readKimiFirstNonEmptyString(record, paths) {
-    if (!record) {
-        return null;
-    }
-    for (const path of paths) {
-        const value = readKimiPath(record, path);
-        if (typeof value === "string" && value.trim()) {
-            return value.trim();
-        }
-    }
-    return null;
-}
-export function readKimiFirstPresentValue(record, paths) {
-    if (!record) {
-        return null;
-    }
-    for (const path of paths) {
-        const value = readKimiPath(record, path);
-        if (value === undefined || value === null) {
-            continue;
-        }
-        if (typeof value === "string" && !value.trim()) {
-            continue;
-        }
-        return value;
-    }
-    return null;
-}
-export function resolveKimiMessageRole(record) {
-    const rawRole = readKimiFirstNonEmptyString(record, [
-        ["role"],
-        ["message", "role"],
-        ["message", "payload", "role"],
-        ["payload", "role"],
-        ["event", "role"],
-        ["author", "role"],
-        ["speaker"]
-    ]) ?? "";
-    const normalized = rawRole.trim().toLowerCase();
-    if (normalized === "user" || normalized === "human") {
-        return "user";
-    }
-    if (normalized === "assistant" || normalized === "ai" || normalized === "model") {
-        return "assistant";
-    }
-    if (normalized === "tool") {
-        return "tool";
-    }
-    if (normalized === "system" || normalized.includes("system")) {
-        return "system";
-    }
-    const rawType = readKimiMessageType(record);
-    if (rawType === "user" || rawType === "assistant" || rawType === "tool" || rawType === "system") {
-        return rawType;
-    }
-    return "assistant";
-}
-export function extractKimiMessageBlocks(record) {
-    const directCandidates = [
-        record.content,
-        record.tool_calls,
-        readKimiPath(record, ["message", "content"]),
-        readKimiPath(record, ["message", "payload"]),
-        readKimiPath(record, ["message", "payload", "content"]),
-        readKimiPath(record, ["message", "payload", "text"]),
-        readKimiPath(record, ["message", "payload", "tool_calls"]),
-        readKimiPath(record, ["payload", "content"]),
-        readKimiPath(record, ["payload"]),
-        readKimiPath(record, ["payload", "text"]),
-        readKimiPath(record, ["event", "content"]),
-        readKimiPath(record, ["data", "content"]),
-        record.parts,
-        readKimiPath(record, ["delta", "content"]),
-        record.tool,
-        record.toolCall,
-        record.tool_call,
-        record.function_call,
-        record.toolResult,
-        record.tool_result,
-        record.function_result
-    ];
-    for (const candidate of directCandidates) {
-        if (Array.isArray(candidate) && candidate.length > 0) {
-            return candidate;
-        }
-        if (candidate && typeof candidate === "object") {
-            return [candidate];
-        }
-    }
-    return [];
-}
-export function looksLikeKimiMessagePayload(payload, wireType = "") {
-    return (wireType.includes("message") ||
-        wireType.includes("text") ||
-        wireType.includes("delta") ||
-        wireType.includes("think") ||
-        wireType.includes("tool") ||
-        wireType.includes("function") ||
-        extractKimiMessageBlocks(payload).length > 0 ||
-        looksLikeSelfContainedKimiBlock(payload) ||
-        readKimiPath(payload, ["text"]) !== undefined ||
-        readKimiPath(payload, ["message"]) !== undefined);
-}
-export function normalizeKimiMessageRecord(record) {
-    if (isKimiInternalRecord(record)) {
-        return [];
-    }
-    const fallbackRole = resolveKimiMessageRole(record);
-    if (looksLikeSelfContainedKimiBlock(record)) {
-        const normalized = normalizeKimiMessageBlock(record, fallbackRole);
-        if (normalized) {
-            return [
-                {
-                    ...normalized,
-                    partIndex: 0
-                }
-            ];
-        }
-    }
-    const blocks = extractKimiMessageBlocks(record);
-    if (blocks.length > 0) {
-        const normalizedBlocks = blocks
-            .map((block, blockIndex) => {
-            const normalized = normalizeKimiMessageBlock(block, fallbackRole);
-            if (!normalized) {
-                return null;
-            }
-            return {
-                ...normalized,
-                partIndex: blockIndex
-            };
-        })
-            .filter((block) => block !== null);
-        if (normalizedBlocks.length > 0) {
-            return normalizedBlocks;
-        }
-    }
-    const fallbackText = extractKimiFallbackMessageText(record).trim();
-    if (!fallbackText) {
-        return [];
-    }
-    return [
-        {
-            role: fallbackRole,
-            kind: inferKimiFallbackMessageKind(record),
-            content: fallbackText,
-            toolCall: null,
-            partIndex: null
-        }
-    ];
-}
-function isKimiInternalRecord(record) {
-    const rawRole = (readKimiFirstNonEmptyString(record, [
-        ["role"],
-        ["message", "role"],
-        ["message", "payload", "role"],
-        ["payload", "role"]
-    ]) ?? "").trim().toLowerCase();
-    if (rawRole.startsWith("_")) {
-        return true;
-    }
-    const rawType = readKimiMessageType(record);
-    return (rawType === "metadata"
-        || rawType === "statusupdate"
-        || rawType === "turnbegin"
-        || rawType === "stepend"
-        || rawType === "stepbegin"
-        || rawType === "stepinterrupted"
-        || rawType === "turnend"
-        || (rawType === "contentpart" && !hasKimiDisplayPayload(record)));
-}
-function normalizeKimiMessageBlock(block, fallbackRole) {
-    if (typeof block === "string") {
-        const content = sanitizeKimiDisplayText(block);
-        if (!content) {
-            return null;
-        }
-        return {
-            role: fallbackRole,
-            kind: "text",
-            content,
-            toolCall: null
-        };
-    }
-    if (!block || typeof block !== "object") {
-        return null;
-    }
-    const record = block;
-    const rawType = readKimiMessageType(record);
-    if (rawType.includes("think") || rawType.includes("reason")) {
-        const content = sanitizeKimiDisplayText(extractKimiTextContent(record));
-        if (!content) {
-            return null;
-        }
-        return {
-            role: "assistant",
-            kind: "thinking",
-            content,
-            toolCall: null
-        };
-    }
-    if (rawType.includes("tool_call") ||
-        rawType.includes("toolcall") ||
-        rawType.includes("tool-use") ||
-        rawType.includes("tool_use") ||
-        rawType.includes("function_call") ||
-        hasKimiToolCallShape(record)) {
-        const callId = readKimiFirstNonEmptyString(record, [
-            ["id"],
-            ["callId"],
-            ["call_id"],
-            ["tool_use_id"],
-            ["payload", "id"],
-            ["message", "payload", "id"],
-            ["tool_call", "id"],
-            ["function_call", "id"],
-            ["tool_calls", "0", "id"]
-        ]) ??
-            "kimi-tool-call";
-        const name = readKimiFirstNonEmptyString(record, [
-            ["name"],
-            ["tool", "name"],
-            ["function", "name"],
-            ["payload", "function", "name"],
-            ["message", "payload", "function", "name"],
-            ["tool_call", "name"],
-            ["function_call", "name"],
-            ["tool_calls", "0", "function", "name"]
-        ]) ??
-            "unknown_tool";
-        const patchText = buildKimiApplyPatchFromToolRecord(record);
-        const input = extractKimiFallbackMessageText(readKimiPath(record, ["arguments"]) ??
-            readKimiPath(record, ["input"]) ??
-            readKimiPath(record, ["params"]) ??
-            readKimiPath(record, ["payload", "function", "arguments"]) ??
-            readKimiPath(record, ["message", "payload", "function", "arguments"]) ??
-            readKimiPath(record, ["tool_call", "arguments"]) ??
-            readKimiPath(record, ["tool_call", "input"]) ??
-            readKimiPath(record, ["function_call", "arguments"]) ??
-            readKimiPath(record, ["function_call", "input"]) ??
-            readKimiPath(record, ["tool_calls", "0", "function", "arguments"]));
-        const output = extractKimiFallbackMessageText(readKimiPath(record, ["output"]) ??
-            readKimiPath(record, ["result"]) ??
-            readKimiPath(record, ["payload", "output"]) ??
-            readKimiPath(record, ["message", "payload", "output"]) ??
-            readKimiPath(record, ["tool_call", "output"]) ??
-            readKimiPath(record, ["function_call", "output"]));
-        return {
-            role: patchText ? "tool" : "assistant",
-            kind: "tool_call",
-            content: patchText || output || input || name,
-            toolCall: {
-                callId,
-                name: patchText ? "apply_patch" : name,
-                input: patchText || input,
-                output: output || null,
-                error: null,
-                status: output ? "completed" : "running"
-            }
-        };
-    }
-    if (rawType.includes("tool_result") ||
-        rawType.includes("toolresult") ||
-        rawType.includes("tool-output") ||
-        rawType.includes("tool_output") ||
-        rawType.includes("function_result") ||
-        hasKimiToolResultShape(record)) {
-        const callId = readKimiFirstNonEmptyString(record, [
-            ["tool_use_id"],
-            ["callId"],
-            ["call_id"],
-            ["id"],
-            ["tool_call_id"],
-            ["payload", "tool_call_id"],
-            ["message", "payload", "tool_call_id"],
-            ["tool_result", "call_id"],
-            ["function_result", "call_id"]
-        ]) ??
-            "kimi-tool-call";
-        const output = sanitizeKimiToolResultText(extractKimiFallbackMessageText(readKimiPath(record, ["output"]) ??
-            readKimiPath(record, ["result"]) ??
-            readKimiPath(record, ["content"]) ??
-            readKimiPath(record, ["payload", "return_value", "output"]) ??
-            readKimiPath(record, ["message", "payload", "return_value", "output"]) ??
-            readKimiPath(record, ["payload", "display"]) ??
-            readKimiPath(record, ["message", "payload", "display"]) ??
-            readKimiPath(record, ["tool_result", "output"]) ??
-            readKimiPath(record, ["function_result", "output"])));
-        const isError = readKimiFirstPresentValue(record, [
-            ["payload", "return_value", "is_error"],
-            ["message", "payload", "return_value", "is_error"]
-        ]) === true;
-        const messageText = readKimiFirstNonEmptyString(record, [
-            ["payload", "return_value", "message"],
-            ["message", "payload", "return_value", "message"],
-            ["error"],
-            ["failure"],
-            ["tool_result", "error"],
-            ["function_result", "error"]
-        ]) ?? null;
-        const error = isError
-            ? messageText ?? "KIMI_TOOL_RESULT_FAILED"
-            : null;
-        return {
-            role: "tool",
-            kind: "tool_result",
-            content: output || messageText || error || "",
-            toolCall: {
-                callId,
-                name: readKimiFirstNonEmptyString(record, [
-                    ["name"],
-                    ["tool", "name"],
-                    ["payload", "function", "name"],
-                    ["message", "payload", "function", "name"],
-                    ["tool_result", "name"],
-                    ["function_result", "name"]
-                ]) ?? "tool_result",
-                input: "",
-                output: output || null,
-                error,
-                status: isError || error ? "failed" : "completed"
-            }
-        };
-    }
-    const content = sanitizeKimiDisplayText(extractKimiTextContent(record));
-    if (!content) {
-        return null;
-    }
-    return {
-        role: fallbackRole,
-        kind: "text",
-        content,
-        toolCall: null
-    };
-}
-function readKimiMessageType(record) {
-    return (readKimiFirstNonEmptyString(record, [
-        ["type"],
-        ["kind"],
-        ["eventType"],
-        ["name"],
-        ["message", "type"],
-        ["message", "payload", "type"],
-        ["payload", "type"],
-        ["tool_call", "type"],
-        ["tool_result", "type"],
-        ["function_call", "type"],
-        ["function_result", "type"]
-    ]) ?? "")
-        .trim()
-        .toLowerCase();
-}
-function looksLikeSelfContainedKimiBlock(record) {
-    const rawType = readKimiMessageType(record);
-    if (rawType.includes("think") ||
-        rawType.includes("reason") ||
-        rawType.includes("toolcall") ||
-        rawType.includes("toolresult") ||
-        rawType.includes("tool") ||
-        rawType.includes("function")) {
-        return true;
-    }
-    return hasKimiToolCallShape(record) || hasKimiToolResultShape(record);
-}
-function extractKimiFallbackMessageText(value) {
-    if (typeof value === "string") {
-        return sanitizeKimiDisplayText(value);
-    }
-    if (value === undefined || value === null) {
-        return "";
-    }
-    return sanitizeKimiDisplayText(extractKimiTextContent(value) || ensureText(value));
-}
-function hasKimiDisplayPayload(record) {
-    return extractKimiTextContent(record).trim().length > 0;
-}
-function extractKimiTextContent(value) {
-    if (typeof value === "string") {
-        return value;
-    }
-    if (!value || typeof value !== "object") {
-        return extractTextBlocks(value);
-    }
-    const record = value;
-    const directValue = readKimiFirstPresentValue(record, [
-        ["text"],
-        ["content"],
-        ["message", "payload"],
-        ["message", "payload", "text"],
-        ["message", "payload", "content"],
-        ["payload"],
-        ["payload", "text"],
-        ["payload", "content"],
-        ["delta"],
-        ["delta", "text"],
-        ["delta", "content"]
-    ]);
-    if (directValue !== null) {
-        const extracted = extractTextBlocks(directValue);
-        if (extracted.trim().length > 0) {
-            return extracted;
-        }
-    }
-    return extractTextBlocks(value);
-}
-function sanitizeKimiToolResultText(value) {
-    const stripped = value.replace(/<system>[\s\S]*?<\/system>\s*/gi, "").trim();
-    return stripped || value.trim();
-}
-function buildKimiApplyPatchFromToolRecord(record) {
-    const candidates = [
-        toKimiRecord(readKimiPath(record, ["payload", "function", "arguments"])),
-        toKimiRecord(readKimiPath(record, ["message", "payload", "function", "arguments"])),
-        toKimiRecord(readKimiPath(record, ["tool_calls", "0", "function", "arguments"])),
-        toKimiRecord(readKimiPath(record, ["arguments"])),
-        toKimiRecord(readKimiPath(record, ["input"])),
-        toKimiRecord(readKimiPath(record, ["params"]))
-    ];
-    for (const candidate of candidates) {
-        if (!candidate) {
-            continue;
-        }
-        const patchText = buildApplyPatchFromStructuredFileTool(candidate);
-        if (patchText) {
-            return patchText;
-        }
-    }
-    return null;
-}
-function toKimiRecord(value) {
-    if (!value) {
-        return null;
-    }
-    if (typeof value === "string") {
-        try {
-            const parsed = JSON.parse(value);
-            return parsed && typeof parsed === "object" && !Array.isArray(parsed)
-                ? parsed
-                : null;
-        }
-        catch {
-            return null;
-        }
-    }
-    return typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-function inferKimiFallbackMessageKind(record) {
-    const rawType = ensureText(record.type).toLowerCase();
-    if (rawType.includes("think") || rawType.includes("reason")) {
-        return "thinking";
-    }
-    return "text";
-}
-function hasKimiToolCallShape(record) {
-    return (typeof readKimiPath(record, ["tool_calls"]) !== "undefined" ||
-        typeof readKimiPath(record, ["arguments"]) !== "undefined" ||
-        typeof readKimiPath(record, ["input"]) !== "undefined" ||
-        typeof readKimiPath(record, ["payload", "function"]) !== "undefined" ||
-        typeof readKimiPath(record, ["message", "payload", "function"]) !== "undefined" ||
-        typeof readKimiPath(record, ["tool_call"]) !== "undefined" ||
-        typeof readKimiPath(record, ["function_call"]) !== "undefined");
-}
-function hasKimiToolResultShape(record) {
-    return (typeof readKimiPath(record, ["tool_call_id"]) !== "undefined" ||
-        typeof readKimiPath(record, ["output"]) !== "undefined" ||
-        typeof readKimiPath(record, ["result"]) !== "undefined" ||
-        typeof readKimiPath(record, ["payload", "return_value"]) !== "undefined" ||
-        typeof readKimiPath(record, ["message", "payload", "return_value"]) !== "undefined" ||
-        typeof readKimiPath(record, ["tool_result"]) !== "undefined" ||
-        typeof readKimiPath(record, ["function_result"]) !== "undefined");
-}
-export function sanitizeKimiPlainTextLine(line) {
-    const normalized = line.trim().toLowerCase();
-    if (KIMI_CONTROL_TEXT_LINES.has(normalized) || KIMI_STATUS_TOKEN_PATTERN.test(line.trim())) {
-        return "";
-    }
-    return line.trim();
-}
-export function extractKimiDisplayTextSegments(value) {
-    const stripped = stripKimiSystemReminderBlocks(value);
-    const lines = stripped.replace(/\r\n/g, "\n").split("\n");
-    const transcriptSegments = extractKimiTranscriptSegments(lines);
-    if (transcriptSegments !== null) {
-        return transcriptSegments;
-    }
-    const fallback = sanitizeKimiDisplayTextLines(lines);
-    return fallback ? [fallback] : [];
-}
-function sanitizeKimiDisplayText(value) {
-    return extractKimiDisplayTextSegments(value)
-        .join("\n\n")
-        .replace(/\n{3,}/g, "\n\n")
-        .trim();
-}
-function stripKimiSystemReminderBlocks(value) {
-    return value.replace(/<system-reminder\b[^>]*>[\s\S]*?<\/system-reminder>/gi, "");
-}
-function extractKimiTranscriptSegments(lines) {
-    const hasContentPart = lines.some((line) => line.trim().toLowerCase() === "contentpart");
-    if (!hasContentPart) {
-        return null;
-    }
-    const segments = [];
-    const currentLines = [];
-    let capturing = false;
-    let skipNextStatusToken = false;
-    const flushCurrentSegment = () => {
-        const content = normalizeKimiTranscriptSegment(currentLines.join("\n"));
-        currentLines.length = 0;
-        if (!content) {
-            return;
-        }
-        segments.push(content);
-    };
-    for (const line of lines) {
-        const trimmed = line.trim();
-        const normalized = trimmed.toLowerCase();
-        if (skipNextStatusToken) {
-            if (!trimmed) {
-                continue;
-            }
-            if (KIMI_STATUS_TOKEN_PATTERN.test(trimmed)) {
-                skipNextStatusToken = false;
-                continue;
-            }
-            skipNextStatusToken = false;
-        }
-        if (normalized === "contentpart") {
-            flushCurrentSegment();
-            capturing = true;
-            continue;
-        }
-        if (KIMI_CONTROL_TEXT_LINES.has(normalized)) {
-            if (normalized === "statusupdate") {
-                skipNextStatusToken = true;
-            }
-            flushCurrentSegment();
-            capturing = false;
-            continue;
-        }
-        if (KIMI_STATUS_TOKEN_PATTERN.test(trimmed)) {
-            flushCurrentSegment();
-            capturing = false;
-            continue;
-        }
-        if (!capturing) {
-            continue;
-        }
-        if (!trimmed) {
-            if (currentLines.length > 0 && currentLines.at(-1) !== "") {
-                currentLines.push("");
-            }
-            continue;
-        }
-        currentLines.push(line.trimEnd());
-    }
-    flushCurrentSegment();
-    return collapseKimiTranscriptSegments(segments);
-}
-function collapseKimiTranscriptSegments(segments) {
-    const collapsed = [];
-    for (const segment of segments) {
-        const normalizedSegment = normalizeKimiTranscriptSegment(segment);
-        if (!normalizedSegment) {
-            continue;
-        }
-        const previous = collapsed.at(-1);
-        if (!previous) {
-            collapsed.push(normalizedSegment);
-            continue;
-        }
-        const comparablePrevious = normalizeComparableKimiTranscriptText(previous);
-        const comparableCurrent = normalizeComparableKimiTranscriptText(normalizedSegment);
-        if (!comparableCurrent || comparableCurrent === comparablePrevious) {
-            continue;
-        }
-        if (comparableCurrent.includes(comparablePrevious)) {
-            collapsed[collapsed.length - 1] = normalizedSegment;
-            continue;
-        }
-        if (comparablePrevious.includes(comparableCurrent)) {
-            continue;
-        }
-        collapsed.push(normalizedSegment);
-    }
-    return collapsed;
-}
-function normalizeComparableKimiTranscriptText(value) {
-    return value
-        .trim()
-        .toLowerCase()
-        .replace(/\s+/g, " ");
-}
-function normalizeKimiTranscriptSegment(value) {
-    return value
-        .replace(/\n{3,}/g, "\n\n")
-        .trim();
-}
-function sanitizeKimiDisplayTextLines(lines) {
-    const keptLines = [];
-    let skipNextStatusToken = false;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        const normalized = trimmed.toLowerCase();
-        if (skipNextStatusToken) {
-            if (!trimmed) {
-                continue;
-            }
-            if (KIMI_STATUS_TOKEN_PATTERN.test(trimmed)) {
-                skipNextStatusToken = false;
-                continue;
-            }
-            skipNextStatusToken = false;
-        }
-        if (KIMI_CONTROL_TEXT_LINES.has(normalized)) {
-            if (normalized === "statusupdate") {
-                skipNextStatusToken = true;
-            }
-            continue;
-        }
-        keptLines.push(line);
-    }
-    return keptLines
-        .join("\n")
-        .replace(/\n{3,}/g, "\n\n")
-        .trim();
-}
-//# sourceMappingURL=kimi-message-normalizer.js.map