@jingyi0605/codingns 0.7.4 → 0.8.0

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

@@ -1,963 +0,0 @@
-import { appendFileSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { buildSessionRawStoreRef, normalizeOpenCodeMessageEnvelopes, normalizeOpenCodePartMessage, normalizeOpenCodeToolStatus, parseSessionIdFromRawStoreRef, toJsonRecord } from "../providers/opencode-shared.js";
-import { createOpenCodeMessagePermissionOptions } from "../providers/opencode-permissions.js";
-import { ensureText, extractTextBlocks, nextTimestamp, normalizeWorkspacePath } from "../providers/utils.js";
-const DEFAULT_REQUEST_TIMEOUT_MS = 10_000;
-const TIMEOUT_WARNING_THRESHOLD_MS = 15_000;
-const MAX_CONSECUTIVE_TIMEOUTS = 5;
-const OPENCODE_STALE_EVENT_GRACE_MS = 15_000;
-const OPENCODE_REALISTIC_EPOCH_MS_THRESHOLD = Date.UTC(2000, 0, 1);
-const OPENCODE_SUBMIT_TIMEOUT_AMBIGUOUS = "OPENCODE_SUBMIT_TIMEOUT_AMBIGUOUS";
-const OPENCODE_ORDER_DEBUG_ENABLED = /^(1|true|yes)$/i.test(process.env.CODINGNS_OPENCODE_ORDER_DEBUG?.trim() ?? "");
-const OPENCODE_ORDER_DEBUG_FILE_PATH = resolveOpenCodeOrderDebugFilePath();
-export class OpenCodeRuntimeAdapter {
-    options;
-    providerId = "opencode";
-    constructor(options = {}) {
-        this.options = options;
-    }
-    async startSession(request, sink) {
-        const providerSessionId = await this.createSession(request.workspacePath);
-        const rawStoreRef = buildSessionRawStoreRef(providerSessionId);
-        sink.updateSessionBinding({
-            providerSessionId,
-            rawStoreRef
-        });
-        return this.createLaunchResult(request, sink, providerSessionId, rawStoreRef);
-    }
-    async continueSession(request, sink) {
-        const providerSessionId = this.resolveProviderSessionId(request.providerSessionId, request.rawStoreRef);
-        const rawStoreRef = request.rawStoreRef ?? buildSessionRawStoreRef(providerSessionId);
-        sink.updateSessionBinding({
-            providerSessionId,
-            rawStoreRef
-        });
-        return this.createLaunchResult(request, sink, providerSessionId, rawStoreRef);
-    }
-    createLaunchResult(request, sink, providerSessionId, rawStoreRef) {
-        const abortController = new AbortController();
-        const runStartedAtMs = Date.now();
-        const managedServerLeaseId = this.options.acquireManagedServerLease?.(request.workspacePath)?.trim() || null;
-        const completed = this.runSession(request, {
-            providerSessionId,
-            rawStoreRef,
-            workspacePath: request.workspacePath,
-            runStartedAtMs,
-            sequence: Math.max(0, request.sequenceBase ?? 0),
-            terminalStatus: null,
-            hasObservedActivity: false,
-            currentRunHasAcceptedActivity: false,
-            abortController,
-            sink,
-            messageInfoById: new Map(),
-            partById: new Map(),
-            messageIdByPartId: new Map(),
-            partIdsByMessageId: new Map(),
-            emittedPartSignatures: new Map(),
-            emittedSequenceByMessageId: new Map(),
-            emittedPartOrderByPartId: new Map(),
-            nextPartOrdinalByMessageKind: new Map()
-        }, abortController.signal).finally(() => {
-            if (managedServerLeaseId) {
-                this.options.releaseManagedServerLease?.(request.workspacePath, managedServerLeaseId);
-            }
-        });
-        return {
-            providerSessionId,
-            rawStoreRef,
-            interrupt: async () => {
-                await this.abortSession(providerSessionId, request.workspacePath);
-                abortController.abort();
-            },
-            completed
-        };
-    }
-    async runSession(request, state, signal) {
-        const eventStreamPromise = this.consumeEventStream(state, signal);
-        const promptStartedAt = nextTimestamp();
-        try {
-            await this.sendPrompt(state.providerSessionId, request, signal);
-        }
-        catch (error) {
-            if (signal.aborted) {
-                return;
-            }
-            if (!state.hasObservedActivity && state.terminalStatus === null) {
-                await waitForOpenCodeProgress(state, signal, 1_500);
-            }
-            if (!signal.aborted
-                && !state.hasObservedActivity
-                && state.terminalStatus === null
-                && isOpenCodeSubmitTimeoutAmbiguous(error)) {
-                const acceptedMessage = await this.findAcceptedUserMessage(state.providerSessionId, request.options.providerPrompt?.trim() || request.options.content.trim(), promptStartedAt, request.workspacePath);
-                if (acceptedMessage) {
-                    try {
-                        await eventStreamPromise;
-                    }
-                    catch (streamError) {
-                        if (!signal.aborted
-                            && state.terminalStatus !== "completed"
-                            && state.terminalStatus !== "failed") {
-                            await this.emitRuntimeFailure(state, streamError);
-                        }
-                    }
-                    return;
-                }
-            }
-            if (signal.aborted
-                || state.hasObservedActivity
-                || state.terminalStatus === "completed"
-                || state.terminalStatus === "failed") {
-                try {
-                    await eventStreamPromise;
-                }
-                catch (streamError) {
-                    if (!signal.aborted
-                        && state.terminalStatus !== "completed"
-                        && state.terminalStatus !== "failed") {
-                        await this.emitRuntimeFailure(state, streamError);
-                    }
-                }
-                return;
-            }
-            state.abortController.abort();
-            try {
-                await eventStreamPromise;
-            }
-            catch {
-                // 主动中断流后这里抛出的通常是 abort，直接吞掉。
-            }
-            await this.emitRuntimeFailure(state, error);
-            return;
-        }
-        try {
-            await eventStreamPromise;
-        }
-        catch (error) {
-            if (signal.aborted) {
-                return;
-            }
-            if (state.terminalStatus === "completed" || state.terminalStatus === "failed") {
-                return;
-            }
-            await this.emitRuntimeFailure(state, error);
-        }
-    }
-    async consumeEventStream(state, signal) {
-        const response = await this.fetchResponse("/event", {
-            signal,
-            workspacePath: state.workspacePath
-        });
-        if (!response.body) {
-            throw new Error("OPENCODE_EVENT_STREAM_UNAVAILABLE");
-        }
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        try {
-            while (true) {
-                const next = await reader.read();
-                if (next.done) {
-                    break;
-                }
-                buffer += decoder.decode(next.value, { stream: true });
-                while (true) {
-                    const separatorIndex = buffer.indexOf("\n\n");
-                    if (separatorIndex < 0) {
-                        break;
-                    }
-                    const frame = buffer.slice(0, separatorIndex);
-                    buffer = buffer.slice(separatorIndex + 2);
-                    const payload = extractSseData(frame);
-                    if (!payload) {
-                        continue;
-                    }
-                    const rawEvent = JSON.parse(payload);
-                    const event = unwrapEventPayload(rawEvent);
-                    if (!event) {
-                        continue;
-                    }
-                    logOpenCodeOrderDebug("sse.event", {
-                        providerSessionId: state.providerSessionId,
-                        event
-                    });
-                    const terminal = await this.handleEvent(event, state);
-                    if (terminal) {
-                        return;
-                    }
-                }
-            }
-        }
-        catch (error) {
-            if (signal.aborted) {
-                return;
-            }
-            throw error;
-        }
-        finally {
-            reader.releaseLock();
-        }
-    }
-    async handleEvent(event, state) {
-        const eventType = ensureText(event.type).trim();
-        if (!eventType) {
-            return false;
-        }
-        if (eventType === "session.error") {
-            const properties = toJsonRecord(event.properties) ?? {};
-            const sessionId = ensureText(properties.sessionID).trim();
-            if (sessionId && sessionId !== state.providerSessionId) {
-                return false;
-            }
-            const errorPayload = toJsonRecord(properties.error) ?? {};
-            state.hasObservedActivity = true;
-            state.terminalStatus = "failed";
-            await state.sink.emit({
-                type: "error",
-                status: "failed",
-                providerSessionId: state.providerSessionId,
-                rawStoreRef: state.rawStoreRef,
-                errorCode: ensureText(errorPayload.type).trim() || "OPENCODE_SESSION_ERROR",
-                detail: extractTextBlocks(errorPayload).trim() || "OpenCode session failed",
-                timestamp: nextTimestamp()
-            });
-            return true;
-        }
-        if (eventType === "session.status") {
-            const properties = toJsonRecord(event.properties) ?? {};
-            if (ensureText(properties.sessionID).trim() !== state.providerSessionId) {
-                return false;
-            }
-            const status = toJsonRecord(properties.status) ?? {};
-            const mapped = mapSessionStatus(status);
-            state.hasObservedActivity = true;
-            if (mapped.status === "running") {
-                state.currentRunHasAcceptedActivity = true;
-            }
-            await state.sink.emit({
-                type: "status",
-                status: mapped.status,
-                providerSessionId: state.providerSessionId,
-                rawStoreRef: state.rawStoreRef,
-                detail: mapped.detail,
-                timestamp: nextTimestamp()
-            });
-            return false;
-        }
-        if (eventType === "session.idle") {
-            const properties = toJsonRecord(event.properties) ?? {};
-            if (ensureText(properties.sessionID).trim() !== state.providerSessionId) {
-                return false;
-            }
-            if (!state.currentRunHasAcceptedActivity) {
-                return false;
-            }
-            state.hasObservedActivity = true;
-            state.terminalStatus = "completed";
-            await state.sink.emit({
-                type: "complete",
-                status: "completed",
-                providerSessionId: state.providerSessionId,
-                rawStoreRef: state.rawStoreRef,
-                detail: "OpenCode 本轮输出已结束",
-                timestamp: nextTimestamp()
-            });
-            return true;
-        }
-        if (eventType === "message.updated") {
-            const info = toJsonRecord(toJsonRecord(event.properties)?.info);
-            const messageId = ensureText(info?.id).trim();
-            const sessionId = ensureText(info?.sessionID).trim();
-            if (!info || !messageId || sessionId !== state.providerSessionId) {
-                return false;
-            }
-            if (shouldIgnoreStaleOpenCodeRuntimeEvent(extractOpenCodeMessageInfoTimestampMs(info), state.runStartedAtMs)) {
-                logOpenCodeOrderDebug("sse.event.ignored_stale_message", {
-                    providerSessionId: state.providerSessionId,
-                    messageId,
-                    info
-                });
-                return false;
-            }
-            state.hasObservedActivity = true;
-            state.currentRunHasAcceptedActivity = true;
-            state.messageInfoById.set(messageId, info);
-            const partIds = state.partIdsByMessageId.get(messageId);
-            if (!partIds) {
-                return false;
-            }
-            for (const partId of partIds) {
-                const part = state.partById.get(partId);
-                if (part) {
-                    await this.emitNormalizedPartMessage(part, state);
-                }
-            }
-            return false;
-        }
-        if (eventType === "message.part.updated") {
-            const part = toJsonRecord(toJsonRecord(event.properties)?.part);
-            const partId = ensureText(part?.id).trim();
-            const messageId = ensureText(part?.messageID).trim();
-            const sessionId = ensureText(part?.sessionID).trim();
-            if (!part || !partId || !messageId || sessionId !== state.providerSessionId) {
-                return false;
-            }
-            if (shouldIgnoreStaleOpenCodeRuntimeEvent(extractOpenCodePartTimestampMs(part), state.runStartedAtMs)) {
-                logOpenCodeOrderDebug("sse.event.ignored_stale_part", {
-                    providerSessionId: state.providerSessionId,
-                    messageId,
-                    partId,
-                    part
-                });
-                return false;
-            }
-            state.hasObservedActivity = true;
-            state.currentRunHasAcceptedActivity = true;
-            const merged = mergeRecords(state.partById.get(partId), part);
-            state.partById.set(partId, merged);
-            state.messageIdByPartId.set(partId, messageId);
-            const knownPartIds = state.partIdsByMessageId.get(messageId) ?? new Set();
-            knownPartIds.add(partId);
-            state.partIdsByMessageId.set(messageId, knownPartIds);
-            await this.emitNormalizedPartMessage(merged, state);
-            return false;
-        }
-        if (eventType === "message.part.delta") {
-            const properties = toJsonRecord(event.properties) ?? {};
-            const partId = ensureText(properties.partID).trim();
-            const messageId = ensureText(properties.messageID).trim();
-            const sessionId = ensureText(properties.sessionID).trim();
-            if (!partId || sessionId !== state.providerSessionId) {
-                return false;
-            }
-            const existingPart = state.partById.get(partId);
-            const existingMessage = messageId
-                ? state.messageInfoById.get(messageId)
-                : state.messageInfoById.get(state.messageIdByPartId.get(partId) ?? "");
-            const deltaTimestampMs = firstFiniteNumber(extractOpenCodePartTimestampMs(existingPart), extractOpenCodeMessageInfoTimestampMs(existingMessage));
-            if (shouldIgnoreStaleOpenCodeRuntimeEvent(deltaTimestampMs, state.runStartedAtMs)) {
-                logOpenCodeOrderDebug("sse.event.ignored_stale_delta", {
-                    providerSessionId: state.providerSessionId,
-                    messageId: messageId || state.messageIdByPartId.get(partId) || null,
-                    partId,
-                    properties
-                });
-                return false;
-            }
-            state.hasObservedActivity = true;
-            state.currentRunHasAcceptedActivity = true;
-            const existing = state.partById.get(partId) ?? {};
-            const field = ensureText(properties.field).trim();
-            const delta = ensureText(properties.delta);
-            const knownMessageId = messageId || state.messageIdByPartId.get(partId) || "";
-            const nextPart = {
-                ...existing,
-                id: ensureText(existing.id).trim() || partId,
-                messageID: ensureText(existing.messageID).trim() || knownMessageId,
-                sessionID: ensureText(existing.sessionID).trim() || state.providerSessionId
-            };
-            if (field === "text") {
-                if (!ensureText(nextPart.type).trim()) {
-                    nextPart.type = "text";
-                }
-                nextPart.text = `${ensureText(existing.text)}${delta}`;
-            }
-            state.partById.set(partId, nextPart);
-            if (knownMessageId) {
-                state.messageIdByPartId.set(partId, knownMessageId);
-                const knownPartIds = state.partIdsByMessageId.get(knownMessageId) ?? new Set();
-                knownPartIds.add(partId);
-                state.partIdsByMessageId.set(knownMessageId, knownPartIds);
-            }
-            await this.emitNormalizedPartMessage(nextPart, state);
-            return false;
-        }
-        return false;
-    }
-    async emitNormalizedPartMessage(partPayload, state) {
-        if (!shouldEmitPart(partPayload)) {
-            return;
-        }
-        const partId = ensureText(partPayload.id).trim();
-        const messageId = ensureText(partPayload.messageID).trim() || state.messageIdByPartId.get(partId) || "";
-        const existingMessagePayload = state.messageInfoById.get(messageId);
-        const messagePayload = existingMessagePayload ?? createSyntheticMessagePayload(partPayload, messageId, state.providerSessionId);
-        if (!messageId || !partId || !messagePayload) {
-            return;
-        }
-        state.messageIdByPartId.set(partId, messageId);
-        if (!existingMessagePayload) {
-            state.messageInfoById.set(messageId, messagePayload);
-        }
-        const currentSequence = state.emittedSequenceByMessageId.get(messageId)
-            ?? (() => {
-                state.sequence += 1;
-                state.emittedSequenceByMessageId.set(messageId, state.sequence);
-                return state.sequence;
-            })();
-        const partOrder = resolveOpenCodeRuntimePartOrder(partPayload, messageId, partId, state);
-        const normalized = normalizeOpenCodePartMessage({
-            sessionId: state.providerSessionId,
-            providerSessionId: state.providerSessionId,
-            partId,
-            messageId,
-            partPayload,
-            messagePayload,
-            defaultTimestamp: nextTimestamp(),
-            rawRefOrder: {
-                part: partOrder
-            }
-        });
-        if (!normalized) {
-            return;
-        }
-        const signature = [
-            normalized.kind,
-            normalized.content,
-            normalized.toolCall?.status ?? "",
-            normalized.toolCall?.output ?? "",
-            normalized.toolCall?.error ?? "",
-            normalized.timestamp,
-            normalized.rawRef
-        ].join("|");
-        if (state.emittedPartSignatures.get(partId) === signature) {
-            return;
-        }
-        state.emittedPartSignatures.set(partId, signature);
-        logOpenCodeOrderDebug("runtime.message.emit", {
-            providerSessionId: state.providerSessionId,
-            messageId,
-            partId,
-            sequence: currentSequence,
-            normalized: {
-                messageId: normalized.messageId,
-                role: normalized.role,
-                kind: normalized.kind,
-                timestamp: normalized.timestamp,
-                rawRef: normalized.rawRef,
-                content: normalized.content
-            }
-        });
-        await state.sink.emit({
-            type: "message",
-            providerSessionId: state.providerSessionId,
-            rawStoreRef: state.rawStoreRef,
-            message: {
-                ...normalized,
-                sequence: currentSequence
-            },
-            status: "running",
-            timestamp: normalized.timestamp,
-            rawEventRef: normalized.rawRef
-        });
-    }
-    async createSession(workspacePath) {
-        const response = await this.fetchJson("/session", {
-            method: "POST",
-            headers: {
-                "content-type": "application/json"
-            },
-            query: {
-                directory: workspacePath
-            },
-            body: JSON.stringify({
-                directory: workspacePath
-            }),
-            workspacePath
-        });
-        const sessionId = ensureText(response.id).trim();
-        if (!sessionId) {
-            throw new Error("PROVIDER_SESSION_ID_REQUIRED");
-        }
-        await this.assertSessionDirectory(sessionId, workspacePath);
-        return sessionId;
-    }
-    async assertSessionDirectory(providerSessionId, expectedWorkspacePath) {
-        const response = await this.fetchJson(`/session/${encodeURIComponent(providerSessionId)}`, {
-            workspacePath: expectedWorkspacePath
-        });
-        const actualWorkspacePath = ensureText(response.directory).trim();
-        if (normalizeWorkspacePath(actualWorkspacePath) ===
-            normalizeWorkspacePath(expectedWorkspacePath)) {
-            return;
-        }
-        throw new Error("OPENCODE_SESSION_DIRECTORY_MISMATCH");
-    }
-    resolveProviderSessionId(providerSessionId, rawStoreRef) {
-        const explicit = providerSessionId?.trim();
-        if (explicit) {
-            return explicit;
-        }
-        const parsed = rawStoreRef ? parseSessionIdFromRawStoreRef(rawStoreRef) : null;
-        if (parsed) {
-            return parsed;
-        }
-        throw new Error("PROVIDER_SESSION_ID_REQUIRED");
-    }
-    async sendPrompt(providerSessionId, request, signal) {
-        const content = request.options.providerPrompt?.trim() || request.options.content.trim();
-        if (!content) {
-            throw new Error("INVALID_INPUT");
-        }
-        const body = {
-            ...createOpenCodeMessagePermissionOptions(request.options.permissionMode),
-            parts: [
-                {
-                    type: "text",
-                    text: content
-                }
-            ]
-        };
-        const model = parseModelSelection(request.options.model);
-        if (model) {
-            body.model = model;
-        }
-        await this.fetchJson(`/session/${encodeURIComponent(providerSessionId)}/message`, {
-            method: "POST",
-            headers: {
-                "content-type": "application/json"
-            },
-            body: JSON.stringify(body),
-            signal,
-            timeoutErrorMessage: OPENCODE_SUBMIT_TIMEOUT_AMBIGUOUS,
-            workspacePath: request.workspacePath
-        });
-    }
-    async findAcceptedUserMessage(providerSessionId, content, minTimestamp, workspacePath) {
-        try {
-            const response = await this.fetchJson(`/session/${encodeURIComponent(providerSessionId)}/message`, {
-                query: {
-                    limit: "20"
-                },
-                workspacePath
-            });
-            const messages = normalizeOpenCodeMessageEnvelopes(providerSessionId, providerSessionId, response.reverse());
-            const trimmed = content.trim();
-            for (let index = messages.length - 1; index >= 0; index -= 1) {
-                const message = messages[index];
-                if (message?.role === "user"
-                    && message.content.trim() === trimmed
-                    && isTimestampOnOrAfter(message.timestamp, minTimestamp)) {
-                    return message;
-                }
-            }
-            return null;
-        }
-        catch {
-            return null;
-        }
-    }
-    async emitRuntimeFailure(state, error) {
-        await state.sink.emit({
-            type: "error",
-            status: "failed",
-            providerSessionId: state.providerSessionId,
-            rawStoreRef: state.rawStoreRef,
-            errorCode: mapOpenCodeRuntimeErrorCode(error),
-            detail: error instanceof Error ? error.message : "opencode runtime failed",
-            timestamp: nextTimestamp()
-        });
-    }
-    async abortSession(providerSessionId, workspacePath) {
-        await this.fetchJson(`/session/${encodeURIComponent(providerSessionId)}/abort`, {
-            method: "POST",
-            workspacePath
-        });
-    }
-    async resolveBaseUrl(refresh = false, workspacePath) {
-        const resolved = this.options.baseUrlResolver
-            ? await this.options.baseUrlResolver({ refresh, workspacePath })
-            : this.options.baseUrl?.trim();
-        if (!resolved) {
-            throw new Error("SERVER_UNAVAILABLE");
-        }
-        return resolved.trim().replace(/\/+$/, "");
-    }
-    resolveRequestTimeoutMs() {
-        const configured = this.options.requestTimeoutMs;
-        if (!Number.isFinite(configured)) {
-            return DEFAULT_REQUEST_TIMEOUT_MS;
-        }
-        return Math.max(1_000, Math.floor(configured));
-    }
-    async fetchResponse(pathname, input = {}) {
-        return this.fetchResponseWithRetry(pathname, input, false);
-    }
-    async fetchResponseWithRetry(pathname, input, refresh, timeoutState = createTimeoutRetryState()) {
-        const url = new URL(pathname, `${await this.resolveBaseUrl(refresh, input.workspacePath)}/`);
-        if (input.query) {
-            for (const [key, value] of Object.entries(input.query)) {
-                if (value) {
-                    url.searchParams.set(key, value);
-                }
-            }
-        }
-        const controller = new AbortController();
-        const cleanup = bindAbortSignals(controller, input.signal);
-        const timer = setTimeout(() => {
-            controller.abort();
-        }, this.resolveRequestTimeoutMs());
-        try {
-            const response = await fetch(url, {
-                method: input.method ?? "GET",
-                headers: input.headers,
-                body: input.body,
-                signal: controller.signal
-            });
-            if (!response.ok) {
-                const detail = await safeReadResponseText(response);
-                const mapped = mapRuntimeHttpError(response.status, detail);
-                if (!refresh && isRuntimeServerUnavailableError(mapped) && this.options.baseUrlResolver) {
-                    return this.fetchResponseWithRetry(pathname, input, true);
-                }
-                throw mapped;
-            }
-            return response;
-        }
-        catch (error) {
-            if (controller.signal.aborted) {
-                if (input.signal?.aborted) {
-                    throw error;
-                }
-                if (!isTimeoutRetryableMethod(input.method)) {
-                    throw new Error(input.timeoutErrorMessage ?? "SERVER_TIMEOUT");
-                }
-                const nextTimeoutState = advanceTimeoutRetryState(timeoutState);
-                if (!shouldSurfaceTimeout(nextTimeoutState)) {
-                    if (!refresh && this.options.baseUrlResolver) {
-                        return this.fetchResponseWithRetry(pathname, input, true, nextTimeoutState);
-                    }
-                    return this.fetchResponseWithRetry(pathname, input, refresh, nextTimeoutState);
-                }
-                throw new Error("SERVER_TIMEOUT");
-            }
-            if (isRuntimeRequestUnavailable(error)) {
-                if (!refresh && this.options.baseUrlResolver) {
-                    return this.fetchResponseWithRetry(pathname, input, true, timeoutState);
-                }
-                throw new Error("SERVER_UNAVAILABLE");
-            }
-            throw error;
-        }
-        finally {
-            clearTimeout(timer);
-            cleanup();
-        }
-    }
-    async fetchJson(pathname, input = {}) {
-        const response = await this.fetchResponse(pathname, input);
-        const text = await response.text();
-        return text.length > 0 ? JSON.parse(text) : undefined;
-    }
-}
-function shouldEmitPart(partPayload) {
-    const partType = ensureText(partPayload.type).trim().toLowerCase();
-    if (partType === "text") {
-        const text = ensureText(partPayload.text).trim();
-        return text.length > 0;
-    }
-    if (partType === "reasoning") {
-        const text = ensureText(partPayload.text).trim();
-        return text.length > 0;
-    }
-    if (partType === "tool") {
-        const status = normalizeOpenCodeToolStatus(toJsonRecord(partPayload.state)?.status);
-        return status !== "running";
-    }
-    if (partType === "step-start" || partType === "step-finish") {
-        return false;
-    }
-    return true;
-}
-function createSyntheticMessagePayload(partPayload, messageId, providerSessionId) {
-    const normalizedMessageId = messageId.trim();
-    if (!normalizedMessageId) {
-        return null;
-    }
-    const partTime = toJsonRecord(partPayload.time);
-    const createdAt = typeof partTime?.start === "number"
-        ? partTime.start
-        : typeof partTime?.created === "number"
-            ? partTime.created
-            : typeof partTime?.end === "number"
-                ? partTime.end
-                : null;
-    return {
-        id: normalizedMessageId,
-        sessionID: providerSessionId,
-        // OpenCode 的正文增量经常先于 message.updated 到达。
-        // 这里先用 assistant 占位，保证前端能实时看到同一条消息的连续增长。
-        role: "assistant",
-        time: createdAt === null ? {} : { created: createdAt }
-    };
-}
-function resolveOpenCodeRuntimePartOrder(partPayload, messageId, partId, state) {
-    const existing = state.emittedPartOrderByPartId.get(partId);
-    if (typeof existing === "number" && Number.isFinite(existing) && existing > 0) {
-        return existing;
-    }
-    const kindBucket = resolveOpenCodeRuntimePartKindBucket(partPayload);
-    const counterKey = `${messageId}:${kindBucket}`;
-    const nextOrdinal = (state.nextPartOrdinalByMessageKind.get(counterKey) ?? 0) + 1;
-    const partOrder = kindBucket * 1_000 + nextOrdinal;
-    state.nextPartOrdinalByMessageKind.set(counterKey, nextOrdinal);
-    state.emittedPartOrderByPartId.set(partId, partOrder);
-    return partOrder;
-}
-function resolveOpenCodeRuntimePartKindBucket(partPayload) {
-    const partType = ensureText(partPayload.type).trim().toLowerCase();
-    if (partType === "reasoning" || partType === "thinking") {
-        return 1;
-    }
-    if (partType === "text") {
-        return 2;
-    }
-    if (partType === "tool" || partType === "patch") {
-        return 3;
-    }
-    return 4;
-}
-function shouldIgnoreStaleOpenCodeRuntimeEvent(eventTimestampMs, runStartedAtMs) {
-    if (eventTimestampMs === null
-        || !Number.isFinite(eventTimestampMs)
-        || eventTimestampMs < OPENCODE_REALISTIC_EPOCH_MS_THRESHOLD) {
-        return false;
-    }
-    return eventTimestampMs + OPENCODE_STALE_EVENT_GRACE_MS < runStartedAtMs;
-}
-function extractOpenCodePartTimestampMs(partPayload) {
-    const partTime = toJsonRecord(partPayload?.time);
-    return firstFiniteNumber(partTime?.start, partTime?.created, partTime?.end);
-}
-function extractOpenCodeMessageInfoTimestampMs(messagePayload) {
-    const messageTime = toJsonRecord(messagePayload?.time);
-    return firstFiniteNumber(messageTime?.created, messageTime?.completed, messageTime?.updated);
-}
-function firstFiniteNumber(...values) {
-    for (const value of values) {
-        if (typeof value === "number" && Number.isFinite(value)) {
-            return value;
-        }
-    }
-    return null;
-}
-function logOpenCodeOrderDebug(scope, detail) {
-    if (!OPENCODE_ORDER_DEBUG_ENABLED) {
-        return;
-    }
-    const payload = {
-        timestamp: new Date().toISOString(),
-        scope,
-        ...detail
-    };
-    console.info(`[opencode-order-host] ${scope}`, payload);
-    if (!OPENCODE_ORDER_DEBUG_FILE_PATH) {
-        return;
-    }
-    try {
-        mkdirSync(dirname(OPENCODE_ORDER_DEBUG_FILE_PATH), { recursive: true });
-        appendFileSync(OPENCODE_ORDER_DEBUG_FILE_PATH, `${JSON.stringify(payload)}\n`, "utf8");
-    }
-    catch {
-        // 调试日志写失败不能影响主流程。
-    }
-}
-function resolveOpenCodeOrderDebugFilePath() {
-    if (!OPENCODE_ORDER_DEBUG_ENABLED) {
-        return null;
-    }
-    const explicit = process.env.CODINGNS_OPENCODE_ORDER_DEBUG_FILE?.trim();
-    if (explicit) {
-        return explicit;
-    }
-    return join(homedir(), "WorkFile", "codingns-opencode-order.ndjson");
-}
-function mergeRecords(current, next) {
-    if (!current) {
-        return { ...next };
-    }
-    const merged = {
-        ...current,
-        ...next
-    };
-    const currentState = toJsonRecord(current.state);
-    const nextState = toJsonRecord(next.state);
-    if (currentState || nextState) {
-        merged.state = {
-            ...(currentState ?? {}),
-            ...(nextState ?? {})
-        };
-    }
-    const currentTime = toJsonRecord(current.time);
-    const nextTime = toJsonRecord(next.time);
-    if (currentTime || nextTime) {
-        merged.time = {
-            ...(currentTime ?? {}),
-            ...(nextTime ?? {})
-        };
-    }
-    return merged;
-}
-async function waitForOpenCodeProgress(state, signal, timeoutMs) {
-    const startedAt = Date.now();
-    while (!signal.aborted
-        && !state.hasObservedActivity
-        && state.terminalStatus === null
-        && Date.now() - startedAt < timeoutMs) {
-        await new Promise((resolve) => {
-            setTimeout(resolve, 50);
-        });
-    }
-}
-function extractSseData(frame) {
-    const lines = frame.split(/\r?\n/);
-    const dataLines = lines
-        .filter((line) => line.startsWith("data:"))
-        .map((line) => line.slice(5).trimStart());
-    if (dataLines.length === 0) {
-        return null;
-    }
-    return dataLines.join("\n");
-}
-function unwrapEventPayload(rawEvent) {
-    const record = toJsonRecord(rawEvent);
-    if (!record) {
-        return null;
-    }
-    const payload = toJsonRecord(record.payload);
-    return payload ?? record;
-}
-function mapSessionStatus(status) {
-    const statusType = ensureText(status.type).trim().toLowerCase();
-    if (statusType === "busy") {
-        return {
-            status: "running",
-            detail: "OpenCode 正在处理这轮输入"
-        };
-    }
-    if (statusType === "retry") {
-        const attempt = ensureText(status.attempt).trim();
-        const message = ensureText(status.message).trim();
-        return {
-            status: "running",
-            detail: message || (attempt ? `OpenCode 正在重试（第 ${attempt} 次）` : "OpenCode 正在重试")
-        };
-    }
-    return {
-        status: "completed",
-        detail: "OpenCode 当前空闲"
-    };
-}
-function parseModelSelection(model) {
-    const normalized = model?.trim();
-    if (!normalized) {
-        return null;
-    }
-    const slashIndex = normalized.indexOf("/");
-    if (slashIndex > 0) {
-        return {
-            providerID: normalized.slice(0, slashIndex),
-            modelID: normalized.slice(slashIndex + 1)
-        };
-    }
-    return null;
-}
-function bindAbortSignals(controller, upstream) {
-    if (!upstream) {
-        return () => {
-            return;
-        };
-    }
-    const handleAbort = () => {
-        controller.abort();
-    };
-    upstream.addEventListener("abort", handleAbort);
-    return () => {
-        upstream.removeEventListener("abort", handleAbort);
-    };
-}
-function mapRuntimeHttpError(statusCode, detail) {
-    if (statusCode === 404) {
-        return new Error("PROVIDER_SESSION_NOT_FOUND");
-    }
-    if (statusCode === 409 && /active|running|busy/i.test(detail)) {
-        return new Error("ACTIVE_RUN_EXISTS");
-    }
-    if (statusCode >= 500) {
-        return new Error("SERVER_UNAVAILABLE");
-    }
-    return new Error(detail || `OPENCODE_HTTP_${statusCode}`);
-}
-async function safeReadResponseText(response) {
-    try {
-        return (await response.text()).trim();
-    }
-    catch {
-        return "";
-    }
-}
-function isRuntimeServerUnavailableError(error) {
-    return error instanceof Error && error.message === "SERVER_UNAVAILABLE";
-}
-function isRuntimeRequestUnavailable(error) {
-    if (!(error instanceof Error)) {
-        return false;
-    }
-    const cause = "cause" in error ? error.cause : null;
-    if (cause && typeof cause === "object" && "code" in cause) {
-        const code = typeof cause.code === "string" ? cause.code : "";
-        if (code === "ECONNREFUSED" || code === "ECONNRESET" || code === "ENOTFOUND") {
-            return true;
-        }
-    }
-    return error.message === "fetch failed";
-}
-function createTimeoutRetryState() {
-    return {
-        startedAtMs: Date.now(),
-        timeoutCount: 0
-    };
-}
-function advanceTimeoutRetryState(state) {
-    return {
-        startedAtMs: state.startedAtMs,
-        timeoutCount: state.timeoutCount + 1
-    };
-}
-function isTimeoutRetryableMethod(method) {
-    const normalized = (method ?? "GET").trim().toUpperCase();
-    return normalized === "GET" || normalized === "HEAD" || normalized === "OPTIONS";
-}
-function shouldSurfaceTimeout(state) {
-    return (state.timeoutCount >= MAX_CONSECUTIVE_TIMEOUTS
-        || Date.now() - state.startedAtMs >= TIMEOUT_WARNING_THRESHOLD_MS);
-}
-function isOpenCodeSubmitTimeoutAmbiguous(error) {
-    return error instanceof Error && error.message === OPENCODE_SUBMIT_TIMEOUT_AMBIGUOUS;
-}
-function isTimestampOnOrAfter(timestamp, minTimestamp) {
-    const timestampMs = Date.parse(timestamp);
-    const minTimestampMs = Date.parse(minTimestamp);
-    if (!Number.isFinite(timestampMs) || !Number.isFinite(minTimestampMs)) {
-        return timestamp >= minTimestamp;
-    }
-    return timestampMs >= minTimestampMs;
-}
-function mapOpenCodeRuntimeErrorCode(error) {
-    if (!(error instanceof Error)) {
-        return "OPENCODE_RUNTIME_FAILED";
-    }
-    if (error.message === OPENCODE_SUBMIT_TIMEOUT_AMBIGUOUS) {
-        return OPENCODE_SUBMIT_TIMEOUT_AMBIGUOUS;
-    }
-    if (error.message === "SERVER_TIMEOUT") {
-        return "OPENCODE_REQUEST_TIMEOUT";
-    }
-    if (error.message === "SERVER_UNAVAILABLE") {
-        return "OPENCODE_SERVER_UNAVAILABLE";
-    }
-    return "OPENCODE_RUNTIME_FAILED";
-}
-//# sourceMappingURL=opencode-runtime.js.map