@jingyi0605/codingns 0.1.0

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

@@ -0,0 +1,732 @@
+import { randomUUID } from "node:crypto";
+import { accessSync, constants, existsSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { delimiter, dirname, isAbsolute, join, sep } from "node:path";
+import { spawn } from "node:child_process";
+import { buildClaudeStableRawRef, normalizeClaudeMessagePart, normalizeClaudeMessageParts, readClaudeMessageId, toClaudeRecord } from "../claude-message-utils.js";
+import { ensureDirectory, ensureText, nextTimestamp, safeDate, stringifyStructuredValue, workspaceSlug } from "../providers/utils.js";
+/**
+ * Claude 真实运行时：通过 claude.cmd 流式读取事件，而不是伪造写文件。
+ */
+export class ClaudeRuntimeAdapter {
+    options;
+    providerId = "claude-code";
+    commandPath;
+    constructor(options) {
+        this.options = options;
+        this.commandPath = resolveClaudeCommand(options.commandPath);
+    }
+    async startSession(request, sink) {
+        const providerSessionId = request.providerSessionId ?? buildPendingClaudeSessionId(request.sessionId);
+        const rawStoreRef = buildClaudePendingRawStoreRef(this.options.homeDir, request.workspacePath, request.sessionId);
+        sink.updateSessionBinding({
+            providerSessionId,
+            rawStoreRef
+        });
+        return this.launchClaude(request, sink, providerSessionId, rawStoreRef, []);
+    }
+    async continueSession(request, sink) {
+        const providerSessionId = ensureNonEmpty(request.providerSessionId, "CLAUDE_PROVIDER_SESSION_ID_REQUIRED");
+        const rawStoreRef = findClaudeSessionFile(this.options.homeDir, providerSessionId) ??
+            request.rawStoreRef ??
+            buildClaudeRawStoreRef(this.options.homeDir, request.workspacePath, providerSessionId);
+        sink.updateSessionBinding({
+            providerSessionId,
+            rawStoreRef
+        });
+        return this.launchClaude(request, sink, providerSessionId, rawStoreRef, ["--resume", providerSessionId]);
+    }
+    launchClaude(request, sink, providerSessionId, rawStoreRef, sessionArgs) {
+        const attachmentDirectories = Array.from(new Set(request.options.attachments.map((attachment) => dirname(attachment.filePath))));
+        const args = [
+            "-p",
+            "--verbose",
+            "--output-format",
+            "stream-json",
+            "--input-format",
+            "stream-json",
+            "--include-partial-messages",
+            ...attachmentDirectories.flatMap((directory) => ["--add-dir", directory]),
+            ...sessionArgs
+        ];
+        const permissionArgs = buildClaudePermissionArgs(request.options.permissionMode);
+        if (permissionArgs.length > 0) {
+            args.push(...permissionArgs);
+        }
+        if (request.options.model) {
+            args.push("--model", request.options.model);
+        }
+        let sequence = 0;
+        const toolNameById = new Map();
+        const stableMessageRefByIdentity = new Map();
+        const streamEventState = {
+            currentMessageKey: null,
+            messages: new Map()
+        };
+        let interrupted = false;
+        let completed = false;
+        let fatalWriteError = null;
+        let fatalWriteErrorCode = null;
+        let stderrBuffer = "";
+        let stdoutBuffer = "";
+        let stdinClosed = false;
+        let activeProviderSessionId = providerSessionId;
+        let activeRawStoreRef = rawStoreRef;
+        const refreshBinding = (parsed) => {
+            const discoveredProviderSessionId = extractClaudeSessionId(parsed);
+            let changed = false;
+            if (discoveredProviderSessionId &&
+                discoveredProviderSessionId !== activeProviderSessionId &&
+                !isPendingClaudeSessionId(discoveredProviderSessionId)) {
+                activeProviderSessionId = discoveredProviderSessionId;
+                changed = true;
+            }
+            if (!isPendingClaudeSessionId(activeProviderSessionId)) {
+                const nextRawStoreRef = findClaudeSessionFile(this.options.homeDir, activeProviderSessionId) ??
+                    buildClaudeRawStoreRef(this.options.homeDir, request.workspacePath, activeProviderSessionId);
+                if (nextRawStoreRef !== activeRawStoreRef) {
+                    activeRawStoreRef = nextRawStoreRef;
+                    this.ensureRuntimeStoreReady(activeRawStoreRef);
+                    changed = true;
+                }
+            }
+            if (changed) {
+                sink.updateSessionBinding({
+                    providerSessionId: activeProviderSessionId,
+                    rawStoreRef: activeRawStoreRef
+                });
+            }
+            return {
+                providerSessionId: activeProviderSessionId,
+                rawStoreRef: activeRawStoreRef
+            };
+        };
+        this.ensureRuntimeStoreReady(activeRawStoreRef);
+        const proc = spawn(this.commandPath, args, {
+            cwd: request.workspacePath,
+            shell: shouldSpawnClaudeViaShell(this.commandPath),
+            windowsHide: true,
+            stdio: ["pipe", "pipe", "pipe"]
+        });
+        let pendingInputWrite = Promise.resolve();
+        const submitDuringRun = (options) => {
+            pendingInputWrite = pendingInputWrite.then(() => writeClaudeStreamingInput(proc, options, completed || interrupted || stdinClosed));
+            return pendingInputWrite;
+        };
+        const bindingRefreshTimer = setInterval(() => {
+            refreshBinding();
+        }, 250);
+        void submitDuringRun(request.options).catch((error) => {
+            if (completed || interrupted) {
+                return;
+            }
+            fatalWriteError = error instanceof Error ? error.message : "claude stdin write failed";
+            fatalWriteErrorCode = "CLAUDE_CLI_STDIN_WRITE_FAILED";
+            stderrBuffer = `${stderrBuffer}\n${fatalWriteError}`.trim();
+            if (!proc.killed) {
+                proc.kill("SIGTERM");
+            }
+        });
+        const completedPromise = new Promise((resolve) => {
+            const shutdownProcessAfterTurn = () => {
+                stdinClosed = true;
+                if (!proc.stdin.destroyed) {
+                    proc.stdin.end();
+                }
+                if (!proc.killed) {
+                    proc.kill("SIGTERM");
+                }
+            };
+            const emitRuntimeError = async (detail, errorCode = "CLAUDE_RUNTIME_ERROR") => {
+                if (completed) {
+                    return;
+                }
+                completed = true;
+                const binding = refreshBinding();
+                await sink.emit({
+                    type: "error",
+                    status: "failed",
+                    providerSessionId: binding.providerSessionId,
+                    rawStoreRef: binding.rawStoreRef,
+                    errorCode,
+                    detail
+                });
+            };
+            const emitRuntimeComplete = async (status, detail) => {
+                if (completed) {
+                    return;
+                }
+                completed = true;
+                const binding = refreshBinding();
+                await sink.emit({
+                    type: status,
+                    status: status === "complete" ? "completed" : "interrupted",
+                    providerSessionId: binding.providerSessionId,
+                    rawStoreRef: binding.rawStoreRef,
+                    detail
+                });
+            };
+            const handleControlLine = (parsed) => {
+                const result = readClaudeResultOutcome(parsed);
+                if (!result) {
+                    return false;
+                }
+                stableMessageRefByIdentity.clear();
+                const settle = result.kind === "complete"
+                    ? emitRuntimeComplete("complete", result.detail)
+                    : emitRuntimeError(result.detail, result.errorCode);
+                void settle.finally(() => {
+                    shutdownProcessAfterTurn();
+                    resolve();
+                });
+                return true;
+            };
+            proc.stdout.setEncoding("utf8");
+            proc.stdout.on("data", (chunk) => {
+                stdoutBuffer += chunk;
+                const lines = stdoutBuffer.split(/\r?\n/);
+                stdoutBuffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed) {
+                        continue;
+                    }
+                    void this.consumeStreamLine({
+                        line: trimmed,
+                        onParsed: handleControlLine,
+                        refreshBinding,
+                        sink,
+                        allocateSequence: () => {
+                            sequence += 1;
+                            return sequence;
+                        },
+                        toolNameById,
+                        stableMessageRefByIdentity,
+                        streamEventState
+                    });
+                }
+            });
+            proc.stderr.setEncoding("utf8");
+            proc.stderr.on("data", (chunk) => {
+                stderrBuffer += chunk;
+            });
+            proc.on("error", (error) => {
+                clearInterval(bindingRefreshTimer);
+                stdinClosed = true;
+                void emitRuntimeError(error.message, "CLAUDE_CLI_SPAWN_FAILED").finally(resolve);
+            });
+            proc.on("close", (code, signal) => {
+                clearInterval(bindingRefreshTimer);
+                stdinClosed = true;
+                if (fatalWriteError) {
+                    void emitRuntimeError(fatalWriteError, fatalWriteErrorCode ?? "CLAUDE_CLI_STDIN_WRITE_FAILED").finally(resolve);
+                    return;
+                }
+                if (interrupted || signal === "SIGTERM" || signal === "SIGINT") {
+                    void emitRuntimeComplete("interrupted", "claude process interrupted").finally(resolve);
+                    return;
+                }
+                if (code === 0) {
+                    void emitRuntimeComplete("complete", "claude turn completed").finally(resolve);
+                    return;
+                }
+                const detail = stderrBuffer.trim() || `claude exited with code ${String(code)}`;
+                void emitRuntimeError(detail, "CLAUDE_CLI_EXIT_NON_ZERO").finally(resolve);
+            });
+        });
+        return {
+            providerSessionId: activeProviderSessionId,
+            rawStoreRef: activeRawStoreRef,
+            completed: completedPromise,
+            submitDuringRun,
+            interrupt: async () => {
+                if (proc.killed) {
+                    return;
+                }
+                interrupted = true;
+                stdinClosed = true;
+                if (!proc.stdin.destroyed) {
+                    proc.stdin.end();
+                }
+                proc.kill("SIGTERM");
+            }
+        };
+    }
+    ensureRuntimeStoreReady(rawStoreRef) {
+        ensureDirectory(dirname(rawStoreRef));
+        if (existsSync(rawStoreRef)) {
+            return;
+        }
+        writeFileSync(rawStoreRef, "", "utf8");
+    }
+    async consumeStreamLine(input) {
+        let parsed;
+        try {
+            parsed = JSON.parse(input.line);
+        }
+        catch {
+            return;
+        }
+        if (input.onParsed(parsed)) {
+            return;
+        }
+        const binding = input.refreshBinding(parsed);
+        const envelopes = collectMessageEnvelopes(parsed, input.streamEventState);
+        for (const envelope of envelopes) {
+            const parts = normalizeClaudeMessageParts(envelope.message.content);
+            for (let partIndex = 0; partIndex < parts.length; partIndex += 1) {
+                const part = parts[partIndex];
+                const normalized = normalizeClaudeMessagePart({
+                    part,
+                    envelope,
+                    providerSessionId: binding.providerSessionId,
+                    partIndex,
+                    timestamp: safeDate(envelope.timestamp, nextTimestamp()),
+                    toolNameById: input.toolNameById,
+                    resolveStableMessageRef: (identity) => {
+                        const existing = input.stableMessageRefByIdentity.get(identity);
+                        if (existing) {
+                            return existing;
+                        }
+                        const sequence = input.allocateSequence();
+                        const created = {
+                            sequence,
+                            rawRef: buildClaudeStableRawRef(binding.rawStoreRef, sequence, partIndex)
+                        };
+                        input.stableMessageRefByIdentity.set(identity, created);
+                        return created;
+                    }
+                });
+                if (!normalized) {
+                    continue;
+                }
+                await input.sink.emit({
+                    type: "message",
+                    providerSessionId: binding.providerSessionId,
+                    rawStoreRef: binding.rawStoreRef,
+                    message: normalized,
+                    status: "running",
+                    rawEventRef: normalized.rawRef
+                });
+            }
+        }
+    }
+}
+function writeClaudeStreamingInput(proc, options, isClosed) {
+    if (isClosed || proc.killed || proc.stdin.destroyed || !proc.stdin.writable) {
+        return Promise.reject(new Error("IN_RUN_INPUT_NOT_SUPPORTED"));
+    }
+    const payload = JSON.stringify(buildClaudeStreamingUserInput(options));
+    return new Promise((resolve, reject) => {
+        proc.stdin.write(`${payload}\n`, "utf8", (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+function buildClaudeStreamingUserInput(options) {
+    return {
+        type: "user",
+        message: {
+            role: "user",
+            content: [
+                {
+                    type: "text",
+                    text: options.providerPrompt ?? options.content
+                }
+            ]
+        }
+    };
+}
+export function buildClaudePermissionArgs(permissionMode) {
+    if (permissionMode === "default" ||
+        permissionMode === "acceptEdits" ||
+        permissionMode === "bypassPermissions") {
+        return ["--permission-mode", permissionMode];
+    }
+    return [];
+}
+function resolveClaudeCommand(explicitPath) {
+    const explicitCandidate = pickFirstNonEmpty(explicitPath, process.env.CODINGNS_CLAUDE_CODE_COMMAND, process.env.CLAUDE_CODE_COMMAND);
+    if (explicitCandidate) {
+        return resolveExecutableCandidate(explicitCandidate) ?? explicitCandidate;
+    }
+    const candidates = process.platform === "win32"
+        ? [
+            "claude.cmd",
+            process.env.APPDATA ? join(process.env.APPDATA, "npm", "claude.cmd") : "",
+            process.env.USERPROFILE
+                ? join(process.env.USERPROFILE, "AppData", "Roaming", "npm", "claude.cmd")
+                : "",
+            "claude"
+        ]
+        : ["claude", "/opt/homebrew/bin/claude", "/usr/local/bin/claude", "/usr/bin/claude"];
+    for (const candidate of candidates) {
+        const resolved = resolveExecutableCandidate(candidate);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return process.platform === "win32" ? "claude.cmd" : "claude";
+}
+function shouldSpawnClaudeViaShell(commandPath) {
+    return process.platform === "win32" && /\.(cmd|bat)$/i.test(commandPath);
+}
+function resolveExecutableCandidate(candidate) {
+    const trimmed = candidate.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (hasPathSegment(trimmed)) {
+        return isExecutableFile(trimmed) ? trimmed : null;
+    }
+    return resolveExecutableOnPath(trimmed);
+}
+function resolveExecutableOnPath(command) {
+    const pathValue = process.env.PATH ?? "";
+    if (!pathValue.trim()) {
+        return null;
+    }
+    const extensions = process.platform === "win32"
+        ? buildWindowsExecutableExtensions(command)
+        : [""];
+    for (const entry of pathValue.split(delimiter)) {
+        const trimmedEntry = entry.trim();
+        if (!trimmedEntry) {
+            continue;
+        }
+        for (const extension of extensions) {
+            const candidatePath = join(trimmedEntry, `${command}${extension}`);
+            if (isExecutableFile(candidatePath)) {
+                return candidatePath;
+            }
+        }
+    }
+    return null;
+}
+function buildWindowsExecutableExtensions(command) {
+    if (/\.[^./\\]+$/.test(command)) {
+        return [""];
+    }
+    const pathExtensions = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD")
+        .split(";")
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0);
+    return ["", ...pathExtensions];
+}
+function hasPathSegment(value) {
+    return isAbsolute(value) || value.includes(sep) || value.includes("/") || value.includes("\\");
+}
+function isExecutableFile(filePath) {
+    if (!existsSync(filePath)) {
+        return false;
+    }
+    if (process.platform === "win32") {
+        return true;
+    }
+    try {
+        accessSync(filePath, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function pickFirstNonEmpty(...values) {
+    for (const value of values) {
+        if (value && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return null;
+}
+function buildPendingClaudeSessionId(sessionId) {
+    return `pending://claude-code/${sessionId}`;
+}
+function isPendingClaudeSessionId(sessionId) {
+    return sessionId.startsWith("pending://claude-code/");
+}
+function buildClaudeRawStoreRef(homeDir, workspacePath, sessionId) {
+    return join(homeDir, "projects", workspaceSlug(workspacePath), `${sessionId}.jsonl`);
+}
+function buildClaudePendingRawStoreRef(homeDir, workspacePath, sessionId) {
+    return join(homeDir, "projects", workspaceSlug(workspacePath), `.pending-${sessionId}.jsonl`);
+}
+function findClaudeSessionFile(homeDir, sessionId) {
+    const projectsDir = join(homeDir, "projects");
+    if (!existsSync(projectsDir)) {
+        return null;
+    }
+    const candidates = readdirSync(projectsDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => join(projectsDir, entry.name, `${sessionId}.jsonl`))
+        .filter((filePath) => existsSync(filePath));
+    if (candidates.length === 0) {
+        return null;
+    }
+    candidates.sort((left, right) => compareClaudeSessionFiles(right, left));
+    return candidates[0] ?? null;
+}
+function compareClaudeSessionFiles(left, right) {
+    const leftStat = statSync(left);
+    const rightStat = statSync(right);
+    if (leftStat.size !== rightStat.size) {
+        return leftStat.size - rightStat.size;
+    }
+    return leftStat.mtimeMs - rightStat.mtimeMs;
+}
+function extractClaudeSessionId(parsed) {
+    const directSessionId = ensureText(parsed?.session_id).trim();
+    if (directSessionId.length > 0) {
+        return directSessionId;
+    }
+    const resultSessionId = ensureText((parsed?.result ?? {}).session_id).trim();
+    if (resultSessionId.length > 0) {
+        return resultSessionId;
+    }
+    return null;
+}
+function ensureNonEmpty(value, errorCode) {
+    if (!value || value.trim().length === 0) {
+        throw new Error(errorCode);
+    }
+    return value.trim();
+}
+function readClaudeResultOutcome(record) {
+    if (ensureText(record.type).trim() !== "result") {
+        return null;
+    }
+    const subtype = ensureText(record.subtype).trim().toLowerCase();
+    const stopReason = ensureText(record.stop_reason).trim();
+    const resultRecord = (record.result ?? {});
+    const nestedStopReason = ensureText(resultRecord.stop_reason).trim();
+    const detailCandidate = ensureText(record.error).trim()
+        || ensureText(record.message).trim()
+        || ensureText(resultRecord.error).trim()
+        || ensureText(resultRecord.message).trim()
+        || stopReason
+        || nestedStopReason;
+    if (!subtype || subtype === "success" || subtype === "completed") {
+        return {
+            kind: "complete",
+            detail: detailCandidate || "claude turn completed"
+        };
+    }
+    return {
+        kind: "error",
+        detail: detailCandidate || `claude result ${subtype}`,
+        errorCode: `CLAUDE_RESULT_${subtype.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}`
+    };
+}
+function collectMessageEnvelopes(record, streamEventState) {
+    if (ensureText(record.type).trim() === "stream_event") {
+        return collectStreamEventEnvelopes(record, streamEventState);
+    }
+    const envelopes = [];
+    const directType = ensureText(record.type).trim();
+    const directMessage = toClaudeRecord(record.message);
+    if (directType === "user" || directType === "assistant") {
+        envelopes.push({
+            type: directType,
+            source: "direct",
+            messageId: readClaudeMessageId(directMessage, record),
+            timestamp: record.timestamp,
+            message: directMessage
+        });
+    }
+    const progressMessage = readProgressEnvelope(record);
+    if (progressMessage) {
+        envelopes.push(progressMessage);
+    }
+    return envelopes;
+}
+function readProgressEnvelope(record) {
+    if (ensureText(record.type) !== "progress") {
+        return null;
+    }
+    const nested = toClaudeRecord(toClaudeRecord(record.data).message);
+    const nestedType = ensureText(nested.type).trim();
+    const nestedMessage = toClaudeRecord(nested.message);
+    if (nestedType !== "user" && nestedType !== "assistant") {
+        return null;
+    }
+    return {
+        type: nestedType,
+        source: "progress",
+        messageId: readClaudeMessageId(nestedMessage, nested),
+        timestamp: nested.timestamp ?? record.timestamp,
+        message: nestedMessage
+    };
+}
+function collectStreamEventEnvelopes(record, state) {
+    const event = toClaudeRecord(record.event);
+    const eventType = ensureText(event.type).trim();
+    if (!eventType) {
+        return [];
+    }
+    if (eventType === "message_start") {
+        const message = toClaudeRecord(event.message);
+        const role = ensureText(message.role).trim();
+        if (role !== "user" && role !== "assistant") {
+            return [];
+        }
+        const messageId = readClaudeMessageId(message, message);
+        const messageKey = messageId || `stream:${randomUUID()}`;
+        const messageState = {
+            type: role,
+            messageId,
+            timestamp: message.timestamp ?? record.timestamp,
+            partsByIndex: new Map()
+        };
+        const initialParts = normalizeClaudeMessageParts(message.content);
+        initialParts.forEach((part, partIndex) => {
+            messageState.partsByIndex.set(partIndex, {
+                part: { ...part }
+            });
+        });
+        state.currentMessageKey = messageKey;
+        state.messages.set(messageKey, messageState);
+        return [];
+    }
+    const messageKey = resolveClaudeStreamMessageKey(record, state);
+    if (!messageKey) {
+        return [];
+    }
+    const messageState = state.messages.get(messageKey);
+    if (!messageState) {
+        return [];
+    }
+    if (record.timestamp !== undefined && record.timestamp !== null) {
+        messageState.timestamp = record.timestamp;
+    }
+    if (eventType === "content_block_start") {
+        const partIndex = readClaudeContentBlockIndex(event);
+        if (partIndex < 0) {
+            return [];
+        }
+        const contentBlock = toClaudeRecord(event.content_block);
+        const partState = {
+            part: { ...contentBlock }
+        };
+        if (ensureText(contentBlock.type).trim() === "tool_use") {
+            partState.jsonBuffer = serializeClaudeToolInput(contentBlock.input);
+        }
+        messageState.partsByIndex.set(partIndex, partState);
+        return [buildClaudeStreamEnvelope(messageState, partIndex)];
+    }
+    if (eventType === "content_block_delta") {
+        const partIndex = readClaudeContentBlockIndex(event);
+        if (partIndex < 0) {
+            return [];
+        }
+        const partState = messageState.partsByIndex.get(partIndex);
+        if (!partState) {
+            return [];
+        }
+        applyClaudeContentBlockDelta(partState, toClaudeRecord(event.delta));
+        return [buildClaudeStreamEnvelope(messageState, partIndex)];
+    }
+    if (eventType === "content_block_stop") {
+        const partIndex = readClaudeContentBlockIndex(event);
+        if (partIndex < 0 || !messageState.partsByIndex.has(partIndex)) {
+            return [];
+        }
+        return [buildClaudeStreamEnvelope(messageState, partIndex)];
+    }
+    if (eventType === "message_delta") {
+        const delta = toClaudeRecord(event.delta);
+        messageState.stopReason = ensureText(delta.stop_reason).trim() || null;
+        return [];
+    }
+    if (eventType === "message_stop") {
+        state.messages.delete(messageKey);
+        if (state.currentMessageKey === messageKey) {
+            state.currentMessageKey = null;
+        }
+    }
+    return [];
+}
+function resolveClaudeStreamMessageKey(record, state) {
+    const event = toClaudeRecord(record.event);
+    const eventMessage = toClaudeRecord(event.message);
+    const eventDelta = toClaudeRecord(event.delta);
+    const directKey = readClaudeMessageId(eventMessage, eventMessage)
+        || ensureText(event.message_id).trim()
+        || ensureText(eventDelta.message_id).trim()
+        || ensureText(record.message_id).trim();
+    if (directKey.length > 0 && state.messages.has(directKey)) {
+        state.currentMessageKey = directKey;
+        return directKey;
+    }
+    if (state.currentMessageKey && state.messages.has(state.currentMessageKey)) {
+        return state.currentMessageKey;
+    }
+    return directKey.length > 0 ? directKey : null;
+}
+function readClaudeContentBlockIndex(event) {
+    const candidates = [event.index, event.content_block_index, event.contentBlockIndex];
+    for (const candidate of candidates) {
+        if (typeof candidate === "number" && Number.isInteger(candidate) && candidate >= 0) {
+            return candidate;
+        }
+    }
+    return -1;
+}
+function buildClaudeStreamEnvelope(messageState, partIndex) {
+    const content = Array.from({ length: partIndex + 1 }, (_, index) => index === partIndex ? { ...(messageState.partsByIndex.get(partIndex)?.part ?? {}) } : "");
+    return {
+        type: messageState.type,
+        source: "stream_event",
+        messageId: messageState.messageId,
+        timestamp: messageState.timestamp,
+        message: {
+            content
+        }
+    };
+}
+function applyClaudeContentBlockDelta(partState, delta) {
+    const deltaType = ensureText(delta.type).trim();
+    if (deltaType === "text_delta") {
+        partState.part.text = `${ensureText(partState.part.text)}${ensureText(delta.text)}`;
+        return;
+    }
+    if (deltaType === "thinking_delta") {
+        partState.part.type = ensureText(partState.part.type).trim() || "thinking";
+        partState.part.thinking = `${ensureText(partState.part.thinking)}${ensureText(delta.thinking)}`;
+        return;
+    }
+    if (deltaType === "input_json_delta") {
+        partState.part.type = ensureText(partState.part.type).trim() || "tool_use";
+        const nextBuffer = `${partState.jsonBuffer ?? ""}${ensureText(delta.partial_json)}`;
+        partState.jsonBuffer = nextBuffer;
+        partState.part.input = parseClaudePartialJson(nextBuffer);
+        return;
+    }
+    if (deltaType === "signature_delta") {
+        partState.part.signature = `${ensureText(partState.part.signature)}${ensureText(delta.signature)}`;
+    }
+}
+function parseClaudePartialJson(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return "";
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return trimmed;
+    }
+}
+function serializeClaudeToolInput(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value === undefined || value === null) {
+        return "";
+    }
+    return stringifyStructuredValue(value);
+}
+//# sourceMappingURL=claude-runtime.js.map