@jingyi0605/codingns 0.8.1 → 0.9.0

package/dist/server/modules/workspace/affairs-lightweight-session-service.js

@@ -0,0 +1,1447 @@
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { AppError } from "../../shared/errors/app-error.js";
+import { createId } from "../../shared/utils/id.js";
+const LIGHTWEIGHT_PROVIDER_IDS = new Set(["codex", "claude-code"]);
+const LIGHTWEIGHT_STORAGE_VERSION = 1;
+const DEFAULT_CLAUDE_MODEL = "claude-sonnet-4-20250514";
+const DEFAULT_OPENAI_MODEL = "gpt-5.4";
+const ANTHROPIC_API_VERSION = "2023-06-01";
+const LIGHTWEIGHT_SESSION_TMP_FILE_SUFFIX = ".tmp";
+const LIGHTWEIGHT_SESSION_READ_RETRY_DELAYS_MS = [12, 40];
+const LIGHTWEIGHT_SYSTEM_PROMPT = [
+    "你是 CodingNS 的事务轻量会话。",
+    "你的职责是快速问答、联网搜索、轻量分析。",
+    "你没有本地文件、终端、浏览器自动化、工作区读写、MCP、本地工具权限。",
+    "如果用户要求你读取本地目录、执行命令、修改文件、调用本地工具，必须明确说当前轻量模式做不到，并建议切到 Agent 会话。",
+    "需要最新信息时，优先使用联网搜索，再给结论。",
+    "回答直接、清楚、少废话。"
+].join("\n");
+export class AffairsLightweightSessionService {
+    hostDataRootDir;
+    sessionLocks = new Map();
+    sessionDocumentCache = new Map();
+    constructor(hostDataRootDir) {
+        this.hostDataRootDir = hostDataRootDir;
+    }
+    async listSessions(workspaceId, userId) {
+        const workspaceDir = this.resolveWorkspaceDir(workspaceId);
+        const entries = await safeReadDir(workspaceDir);
+        const sessions = await Promise.all(entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map(async (entry) => {
+            const document = await this.readSessionDocumentByPath(path.join(workspaceDir, entry.name));
+            return document?.userId === userId ? document.session : null;
+        }));
+        return sessions
+            .filter((item) => Boolean(item))
+            .sort((left, right) => {
+            const leftValue = left.lastMessageAt ?? left.updatedAt;
+            const rightValue = right.lastMessageAt ?? right.updatedAt;
+            return rightValue.localeCompare(leftValue);
+        });
+    }
+    async getSession(workspaceId, sessionId, userId) {
+        const document = await this.requireSessionDocument(workspaceId, sessionId, userId);
+        return document.session;
+    }
+    async readMessages(workspaceId, sessionId, userId) {
+        const document = await this.requireSessionDocument(workspaceId, sessionId, userId);
+        return {
+            messages: document.messages,
+            cursor: null,
+            nextCursor: null,
+            total: document.messages.length
+        };
+    }
+    async markSessionSeen(workspaceId, sessionId, userId, seenAt) {
+        await this.waitForSessionIdle(sessionId);
+        const document = await this.requireSessionDocument(workspaceId, sessionId, userId);
+        const normalizedSeenAt = normalizeOptionalTimestamp(seenAt) ?? new Date().toISOString();
+        const nextActivityState = document.session.activityState === "completed_unread"
+            ? "idle"
+            : document.session.activityState;
+        await this.writeSessionDocument({
+            ...document,
+            session: {
+                ...document.session,
+                lastSeenAt: normalizedSeenAt,
+                activityState: nextActivityState
+            }
+        });
+    }
+    async renameSessionTitle(workspaceId, sessionId, userId, title) {
+        await this.waitForSessionIdle(sessionId);
+        const normalizedTitle = title.trim();
+        if (!normalizedTitle) {
+            throw new AppError({
+                statusCode: 400,
+                errorCode: "INVALID_INPUT",
+                detail: "事务轻量会话标题不能为空",
+                field: "title"
+            });
+        }
+        return this.updateSessionSummary(workspaceId, sessionId, userId, (session) => ({
+            ...session,
+            title: normalizedTitle
+        }));
+    }
+    async updateSessionArchiveState(workspaceId, sessionId, userId, archived) {
+        await this.waitForSessionIdle(sessionId);
+        return this.updateSessionSummary(workspaceId, sessionId, userId, (session) => ({
+            ...session,
+            isArchived: archived
+        }));
+    }
+    async updateSessionFavoriteState(workspaceId, sessionId, userId, favorite) {
+        await this.waitForSessionIdle(sessionId);
+        return this.updateSessionSummary(workspaceId, sessionId, userId, (session) => ({
+            ...session,
+            isFavorite: favorite
+        }));
+    }
+    async deleteSession(workspaceId, sessionId, userId) {
+        await this.waitForSessionIdle(sessionId);
+        await this.requireSessionDocument(workspaceId, sessionId, userId);
+        await fs.unlink(this.resolveSessionFilePath(workspaceId, sessionId));
+        this.sessionDocumentCache.delete(sessionId);
+    }
+    async startSession(input) {
+        const sessionId = createId();
+        const clientRequestId = normalizeClientRequestId(input.clientRequestId);
+        const acceptedAt = new Date().toISOString();
+        const sessionFilePath = this.resolveSessionFilePath(input.workspaceId, sessionId);
+        const providerSessionId = `affairs-lightweight:${input.provider}:${sessionId}`;
+        const session = {
+            sessionId,
+            workspaceId: input.workspaceId,
+            provider: input.provider,
+            providerSessionId,
+            rawStoreRef: sessionFilePath,
+            providerConfigMode: "global-default",
+            providerPresetId: null,
+            parentSessionId: null,
+            isSubagent: false,
+            subagentLabel: null,
+            isArchived: false,
+            isFavorite: false,
+            title: buildDraftTitle(input.content),
+            messageCount: 0,
+            lastMessageAt: null,
+            createdAt: acceptedAt,
+            updatedAt: acceptedAt,
+            syncStatus: "idle",
+            syncCursor: null,
+            lastSyncAt: null,
+            lastErrorCode: null,
+            lastErrorDetail: null,
+            resumedAt: null,
+            runningState: "starting",
+            activitySource: "runtime",
+            lastEventAt: acceptedAt,
+            completedAt: null,
+            lastSeenAt: null,
+            activityState: "running"
+        };
+        const document = {
+            version: LIGHTWEIGHT_STORAGE_VERSION,
+            userId: input.userId,
+            session,
+            messages: []
+        };
+        await this.writeSessionDocument(document);
+        return this.runTurn(document, {
+            workspaceId: input.workspaceId,
+            userId: input.userId,
+            sessionId,
+            content: input.content,
+            clientRequestId,
+            model: input.model ?? null,
+            reasoningLevel: input.reasoningLevel ?? null
+        });
+    }
+    async sendMessage(input) {
+        const document = await this.requireSessionDocument(input.workspaceId, input.sessionId, input.userId);
+        return this.runTurn(document, {
+            ...input,
+            clientRequestId: normalizeClientRequestId(input.clientRequestId)
+        });
+    }
+    async startSessionStream(input, onEvent) {
+        const sessionId = createId();
+        const clientRequestId = normalizeClientRequestId(input.clientRequestId);
+        const acceptedAt = new Date().toISOString();
+        const sessionFilePath = this.resolveSessionFilePath(input.workspaceId, sessionId);
+        const providerSessionId = `affairs-lightweight:${input.provider}:${sessionId}`;
+        const session = {
+            sessionId,
+            workspaceId: input.workspaceId,
+            provider: input.provider,
+            providerSessionId,
+            rawStoreRef: sessionFilePath,
+            providerConfigMode: "global-default",
+            providerPresetId: null,
+            parentSessionId: null,
+            isSubagent: false,
+            subagentLabel: null,
+            isArchived: false,
+            isFavorite: false,
+            title: buildDraftTitle(input.content),
+            messageCount: 0,
+            lastMessageAt: null,
+            createdAt: acceptedAt,
+            updatedAt: acceptedAt,
+            syncStatus: "idle",
+            syncCursor: null,
+            lastSyncAt: null,
+            lastErrorCode: null,
+            lastErrorDetail: null,
+            resumedAt: null,
+            runningState: "starting",
+            activitySource: "runtime",
+            lastEventAt: acceptedAt,
+            completedAt: null,
+            lastSeenAt: null,
+            activityState: "running"
+        };
+        const document = {
+            version: LIGHTWEIGHT_STORAGE_VERSION,
+            userId: input.userId,
+            session,
+            messages: []
+        };
+        await this.writeSessionDocument(document);
+        await this.runTurn(document, {
+            workspaceId: input.workspaceId,
+            userId: input.userId,
+            sessionId,
+            content: input.content,
+            clientRequestId,
+            model: input.model ?? null,
+            reasoningLevel: input.reasoningLevel ?? null
+        }, onEvent);
+    }
+    async sendMessageStream(input, onEvent) {
+        const document = await this.requireSessionDocument(input.workspaceId, input.sessionId, input.userId);
+        await this.runTurn(document, {
+            ...input,
+            clientRequestId: normalizeClientRequestId(input.clientRequestId)
+        }, onEvent);
+    }
+    async runTurn(baseDocument, input, onEvent) {
+        const existingLock = this.sessionLocks.get(baseDocument.session.sessionId);
+        if (existingLock) {
+            throw new AppError({
+                statusCode: 409,
+                errorCode: "SESSION_BUSY",
+                detail: "当前轻量会话还在回复上一条消息"
+            });
+        }
+        const job = this.runTurnInternal(baseDocument, input, onEvent)
+            .finally(() => {
+            this.sessionLocks.delete(baseDocument.session.sessionId);
+        });
+        this.sessionLocks.set(baseDocument.session.sessionId, job);
+        return job;
+    }
+    async runTurnInternal(baseDocument, input, onEvent) {
+        validateLightweightProvider(baseDocument.session.provider);
+        const now = new Date().toISOString();
+        const document = await this.requireSessionDocument(input.workspaceId, input.sessionId, input.userId);
+        const provider = document.session.provider;
+        const userMessage = createUserMessage({
+            provider,
+            providerSessionId: document.session.providerSessionId,
+            sessionId: document.session.sessionId,
+            content: input.content,
+            clientRequestId: input.clientRequestId,
+            sequence: document.messages.length + 1,
+            timestamp: now,
+            rawStoreRef: document.session.rawStoreRef
+        });
+        const runningDocument = {
+            ...document,
+            session: {
+                ...document.session,
+                updatedAt: now,
+                lastMessageAt: now,
+                lastEventAt: now,
+                runningState: "running",
+                activityState: "running",
+                completedAt: null,
+                syncStatus: "syncing",
+                lastSyncAt: now,
+                lastErrorCode: null,
+                lastErrorDetail: null,
+                messageCount: document.messages.length + 1,
+                title: document.session.messageCount === 0 ? buildDraftTitle(input.content) : document.session.title
+            },
+            messages: [...document.messages, userMessage]
+        };
+        await this.writeSessionDocument(runningDocument);
+        await onEvent?.({
+            type: "started",
+            session: runningDocument.session,
+            acceptedAt: now,
+            clientRequestId: input.clientRequestId,
+            userMessage
+        });
+        let workingDocument = runningDocument;
+        try {
+            const handleToolEvent = async (event) => {
+                workingDocument = upsertToolLifecycleMessage({
+                    document: workingDocument,
+                    event,
+                    observedAt: new Date().toISOString()
+                });
+                await this.writeSessionDocument(workingDocument);
+                await onEvent?.({ type: "tool", ...event });
+            };
+            const assistantContent = provider === "codex"
+                ? await this.generateOpenAiResponse(runningDocument, input, onEvent
+                    ? async (delta) => {
+                        await onEvent({ type: "delta", delta });
+                    }
+                    : undefined, handleToolEvent)
+                : await this.generateAnthropicResponse(runningDocument, input, onEvent
+                    ? async (delta) => {
+                        await onEvent({ type: "delta", delta });
+                    }
+                    : undefined, handleToolEvent);
+            const completedAt = new Date().toISOString();
+            const assistantMessage = createAssistantMessage({
+                provider,
+                providerSessionId: workingDocument.session.providerSessionId,
+                sessionId: workingDocument.session.sessionId,
+                content: assistantContent,
+                sequence: workingDocument.messages.length + 1,
+                timestamp: completedAt,
+                rawStoreRef: workingDocument.session.rawStoreRef
+            });
+            const completedDocument = {
+                ...workingDocument,
+                session: {
+                    ...workingDocument.session,
+                    updatedAt: completedAt,
+                    lastMessageAt: completedAt,
+                    lastEventAt: completedAt,
+                    completedAt,
+                    runningState: "completed",
+                    activityState: "completed_unread",
+                    syncStatus: "idle",
+                    lastSyncAt: completedAt,
+                    messageCount: workingDocument.messages.length + 1
+                },
+                messages: [...workingDocument.messages, assistantMessage]
+            };
+            await this.writeSessionDocument(completedDocument);
+            const result = {
+                session: completedDocument.session,
+                acceptedAt: now,
+                clientRequestId: input.clientRequestId,
+                userMessage,
+                assistantMessage,
+                messages: completedDocument.messages
+            };
+            await onEvent?.({
+                type: "completed",
+                result
+            });
+            return result;
+        }
+        catch (error) {
+            const failedAt = new Date().toISOString();
+            const failureMessage = getErrorMessage(error);
+            const failedDocument = {
+                ...workingDocument,
+                session: {
+                    ...workingDocument.session,
+                    updatedAt: failedAt,
+                    lastEventAt: failedAt,
+                    completedAt: failedAt,
+                    runningState: "failed",
+                    activityState: "completed_unread",
+                    syncStatus: "error",
+                    lastSyncAt: failedAt,
+                    lastErrorCode: error instanceof AppError ? error.errorCode : "LIGHTWEIGHT_RUNTIME_FAILED",
+                    lastErrorDetail: failureMessage,
+                    messageCount: workingDocument.messages.length
+                }
+            };
+            await this.writeSessionDocument(failedDocument);
+            await onEvent?.({
+                type: "error",
+                errorCode: error instanceof AppError ? error.errorCode : "LIGHTWEIGHT_RUNTIME_FAILED",
+                detail: failureMessage
+            });
+            throw error;
+        }
+    }
+    async generateOpenAiResponse(document, input, onDelta, onTool) {
+        if (onDelta) {
+            const streamed = await this.generateOpenAiResponseStream(document, input, onDelta, onTool);
+            if (streamed) {
+                return streamed;
+            }
+        }
+        return this.generateOpenAiResponseSync(document, input);
+    }
+    async generateAnthropicResponse(document, input, onDelta, onTool) {
+        if (onDelta) {
+            const streamed = await this.generateAnthropicResponseStream(document, input, onDelta, onTool);
+            if (streamed) {
+                return streamed;
+            }
+        }
+        return this.generateAnthropicResponseSync(document, input);
+    }
+    async generateOpenAiResponseSync(document, input) {
+        const runtime = await this.readOpenAiRuntimeConfig(input.model?.trim() || null);
+        const responsePayload = createOpenAiResponsesPayload({
+            model: runtime.model,
+            messages: document.messages,
+            reasoningLevel: input.reasoningLevel ?? null
+        });
+        const headers = {
+            "content-type": "application/json",
+            authorization: `Bearer ${runtime.apiKey}`
+        };
+        const response = await postJsonWithFallbacks({
+            baseUrl: runtime.baseUrl,
+            pathCandidates: ["responses", "v1/responses"],
+            init: {
+                method: "POST",
+                headers,
+                body: JSON.stringify(responsePayload)
+            }
+        });
+        const body = await parseJsonResponse(response);
+        if (!response.ok) {
+            throw createUpstreamError("OPENAI_LIGHTWEIGHT_FAILED", body, response.status);
+        }
+        const outputText = extractOpenAiResponseText(body);
+        if (outputText) {
+            return outputText;
+        }
+        const fallbackResponse = await postJsonWithFallbacks({
+            baseUrl: runtime.baseUrl,
+            pathCandidates: ["v1/chat/completions", "chat/completions"],
+            init: {
+                method: "POST",
+                headers,
+                body: JSON.stringify(createOpenAiChatPayload({
+                    model: runtime.model,
+                    messages: document.messages
+                }))
+            }
+        });
+        const fallbackBody = await parseJsonResponse(fallbackResponse);
+        if (!fallbackResponse.ok) {
+            throw createUpstreamError("OPENAI_LIGHTWEIGHT_FAILED", fallbackBody, fallbackResponse.status);
+        }
+        const fallbackText = extractOpenAiResponseText(fallbackBody);
+        if (!fallbackText) {
+            throw new AppError({
+                statusCode: 502,
+                errorCode: "OPENAI_LIGHTWEIGHT_EMPTY",
+                detail: "轻量 Codex 没有返回正文"
+            });
+        }
+        return fallbackText;
+    }
+    async generateAnthropicResponseSync(document, input) {
+        const runtime = await this.readAnthropicRuntimeConfig(input.model?.trim() || null);
+        let messages = document.messages.map((message) => ({
+            role: message.role,
+            content: message.content
+        }));
+        let finalBody = null;
+        for (let index = 0; index < 4; index += 1) {
+            const response = await postJsonWithFallbacks({
+                baseUrl: runtime.baseUrl,
+                pathCandidates: ["v1/messages", "messages"],
+                init: {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json",
+                        "anthropic-version": ANTHROPIC_API_VERSION,
+                        "x-api-key": runtime.apiKey
+                    },
+                    body: JSON.stringify({
+                        model: runtime.model,
+                        max_tokens: 2048,
+                        system: LIGHTWEIGHT_SYSTEM_PROMPT,
+                        messages,
+                        tools: [
+                            {
+                                type: "web_search_20250305",
+                                name: "web_search",
+                                max_uses: 5
+                            }
+                        ]
+                    })
+                }
+            });
+            const body = await parseJsonResponse(response);
+            if (!response.ok) {
+                throw createUpstreamError("ANTHROPIC_LIGHTWEIGHT_FAILED", body, response.status);
+            }
+            finalBody = body;
+            const stopReason = normalizeText(body?.stop_reason);
+            const assistantContent = Array.isArray(body?.content) ? body.content : [];
+            if (stopReason === "pause_turn") {
+                messages = [
+                    ...messages,
+                    {
+                        role: "assistant",
+                        content: assistantContent
+                    }
+                ];
+                continue;
+            }
+            break;
+        }
+        const outputText = extractAnthropicOutputText(finalBody?.content);
+        if (!outputText) {
+            throw new AppError({
+                statusCode: 502,
+                errorCode: "ANTHROPIC_LIGHTWEIGHT_EMPTY",
+                detail: "轻量 Claude Code 没有返回正文"
+            });
+        }
+        return outputText;
+    }
+    async generateOpenAiResponseStream(document, input, onDelta, onTool) {
+        const runtime = await this.readOpenAiRuntimeConfig(input.model?.trim() || null);
+        const headers = {
+            "content-type": "application/json",
+            authorization: `Bearer ${runtime.apiKey}`
+        };
+        const responsePayload = {
+            ...createOpenAiResponsesPayload({
+                model: runtime.model,
+                messages: document.messages,
+                reasoningLevel: input.reasoningLevel ?? null
+            }),
+            stream: true
+        };
+        const response = await postJsonWithFallbacks({
+            baseUrl: runtime.baseUrl,
+            pathCandidates: ["responses", "v1/responses"],
+            init: {
+                method: "POST",
+                headers,
+                body: JSON.stringify(responsePayload)
+            }
+        });
+        if (!response.ok) {
+            const body = await parseJsonResponse(response);
+            throw createUpstreamError("OPENAI_LIGHTWEIGHT_FAILED", body, response.status);
+        }
+        const streamedText = await streamOpenAiSseText(response, onDelta, onTool);
+        if (streamedText) {
+            return streamedText;
+        }
+        const fallbackResponse = await postJsonWithFallbacks({
+            baseUrl: runtime.baseUrl,
+            pathCandidates: ["v1/chat/completions", "chat/completions"],
+            init: {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    ...createOpenAiChatPayload({
+                        model: runtime.model,
+                        messages: document.messages
+                    }),
+                    stream: true
+                })
+            }
+        });
+        if (!fallbackResponse.ok) {
+            const fallbackBody = await parseJsonResponse(fallbackResponse);
+            throw createUpstreamError("OPENAI_LIGHTWEIGHT_FAILED", fallbackBody, fallbackResponse.status);
+        }
+        return await streamOpenAiSseText(fallbackResponse, onDelta, onTool);
+    }
+    async generateAnthropicResponseStream(document, input, onDelta, onTool) {
+        const runtime = await this.readAnthropicRuntimeConfig(input.model?.trim() || null);
+        const response = await postJsonWithFallbacks({
+            baseUrl: runtime.baseUrl,
+            pathCandidates: ["v1/messages", "messages"],
+            init: {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    "anthropic-version": ANTHROPIC_API_VERSION,
+                    "x-api-key": runtime.apiKey
+                },
+                body: JSON.stringify({
+                    model: runtime.model,
+                    max_tokens: 2048,
+                    system: LIGHTWEIGHT_SYSTEM_PROMPT,
+                    messages: document.messages.map((message) => ({
+                        role: message.role,
+                        content: message.content
+                    })),
+                    tools: [
+                        {
+                            type: "web_search_20250305",
+                            name: "web_search",
+                            max_uses: 5
+                        }
+                    ],
+                    stream: true
+                })
+            }
+        });
+        if (!response.ok) {
+            const body = await parseJsonResponse(response);
+            throw createUpstreamError("ANTHROPIC_LIGHTWEIGHT_FAILED", body, response.status);
+        }
+        return await streamAnthropicSseText(response, onDelta, onTool);
+    }
+    async requireSessionDocument(workspaceId, sessionId, userId) {
+        const document = await this.readSessionDocument(workspaceId, sessionId);
+        if (!document || document.userId !== userId) {
+            throw new AppError({
+                statusCode: 404,
+                errorCode: "AFFAIRS_LIGHTWEIGHT_SESSION_NOT_FOUND",
+                detail: "未找到对应的事务轻量会话"
+            });
+        }
+        return document;
+    }
+    async readSessionDocument(workspaceId, sessionId) {
+        return this.readSessionDocumentByPath(this.resolveSessionFilePath(workspaceId, sessionId), sessionId);
+    }
+    async readSessionDocumentByPath(filePath, expectedSessionId = inferSessionIdFromSessionFilePath(filePath)) {
+        for (let attemptIndex = 0; attemptIndex <= LIGHTWEIGHT_SESSION_READ_RETRY_DELAYS_MS.length; attemptIndex += 1) {
+            try {
+                const raw = await fs.readFile(filePath, "utf8");
+                const parsed = JSON.parse(raw);
+                if (!parsed || typeof parsed !== "object") {
+                    return this.readCachedSessionDocument(expectedSessionId);
+                }
+                if (!parsed.session || !Array.isArray(parsed.messages)) {
+                    return this.readCachedSessionDocument(expectedSessionId);
+                }
+                this.cacheSessionDocument(parsed);
+                return parsed;
+            }
+            catch (error) {
+                if (error.code === "ENOENT") {
+                    return null;
+                }
+                if (!shouldRetrySessionDocumentRead(error) || attemptIndex >= LIGHTWEIGHT_SESSION_READ_RETRY_DELAYS_MS.length) {
+                    const cached = this.readCachedSessionDocument(expectedSessionId);
+                    if (cached) {
+                        return cached;
+                    }
+                    throw error;
+                }
+                await sleep(LIGHTWEIGHT_SESSION_READ_RETRY_DELAYS_MS[attemptIndex]);
+            }
+        }
+        return this.readCachedSessionDocument(expectedSessionId);
+    }
+    async writeSessionDocument(document) {
+        const filePath = document.session.rawStoreRef;
+        const tempFilePath = `${filePath}.${process.pid}.${createId()}${LIGHTWEIGHT_SESSION_TMP_FILE_SUFFIX}`;
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(tempFilePath, `${JSON.stringify(document, null, 2)}\n`, "utf8");
+        await fs.rename(tempFilePath, filePath);
+        this.cacheSessionDocument(document);
+    }
+    async updateSessionSummary(workspaceId, sessionId, userId, updater) {
+        const document = await this.requireSessionDocument(workspaceId, sessionId, userId);
+        const nextSession = updater(document.session);
+        await this.writeSessionDocument({
+            ...document,
+            session: nextSession
+        });
+        return nextSession;
+    }
+    async waitForSessionIdle(sessionId) {
+        const inflight = this.sessionLocks.get(sessionId);
+        if (inflight) {
+            await inflight;
+        }
+    }
+    cacheSessionDocument(document) {
+        const sessionId = document.session.sessionId?.trim();
+        if (!sessionId) {
+            return;
+        }
+        this.sessionDocumentCache.set(sessionId, cloneSessionDocument(document));
+    }
+    readCachedSessionDocument(sessionId) {
+        const normalizedSessionId = sessionId?.trim() ?? "";
+        if (!normalizedSessionId) {
+            return null;
+        }
+        const cached = this.sessionDocumentCache.get(normalizedSessionId);
+        return cached ? cloneSessionDocument(cached) : null;
+    }
+    async readOpenAiRuntimeConfig(modelOverride) {
+        const injectedConfig = await this.readLightweightRuntimeConfigFile();
+        const authPath = path.join(os.homedir(), ".codex", "auth.json");
+        const configPath = path.join(os.homedir(), ".codex", "config.toml");
+        const auth = await readJsonFile(authPath);
+        const toml = await safeReadTextFile(configPath);
+        const parsed = parseCodexTomlConfig(toml);
+        const key = pickFirstText(process.env.CODINGNS_LIGHTWEIGHT_OPENAI_API_KEY, process.env.OPENAI_API_KEY, injectedConfig?.openai?.apiKey, String(auth?.OPENAI_API_KEY ?? ""));
+        const baseUrl = normalizeBaseUrl(pickFirstText(process.env.CODINGNS_LIGHTWEIGHT_OPENAI_BASE_URL, injectedConfig?.openai?.baseUrl, process.env.OPENAI_BASE_URL, parsed.baseUrl, "https://api.openai.com/v1") ?? "https://api.openai.com/v1");
+        const model = modelOverride
+            || pickFirstText(process.env.CODINGNS_LIGHTWEIGHT_OPENAI_MODEL, injectedConfig?.openai?.model, process.env.OPENAI_MODEL, parsed.model, DEFAULT_OPENAI_MODEL)
+            || DEFAULT_OPENAI_MODEL;
+        if (!key) {
+            throw new AppError({
+                statusCode: 500,
+                errorCode: "OPENAI_LIGHTWEIGHT_AUTH_MISSING",
+                detail: `未找到 Codex 轻量会话可用的 API key。优先检查 ~/.codex/auth.json，或在 ${this.getLightweightRuntimeConfigPath()} 写入 openai.apiKey。`
+            });
+        }
+        return {
+            apiKey: key,
+            baseUrl,
+            model
+        };
+    }
+    async readAnthropicRuntimeConfig(modelOverride) {
+        const injectedConfig = await this.readLightweightRuntimeConfigFile();
+        const settingsPath = path.join(os.homedir(), ".claude", "settings.json");
+        const configPath = path.join(os.homedir(), ".claude", "config.json");
+        const settings = await readJsonFile(settingsPath);
+        const config = await readJsonFile(configPath);
+        const env = typeof settings?.env === "object" && settings.env ? settings.env : {};
+        const key = pickFirstText(process.env.CODINGNS_LIGHTWEIGHT_ANTHROPIC_API_KEY, process.env.ANTHROPIC_API_KEY, injectedConfig?.anthropic?.apiKey, String(env.ANTHROPIC_AUTH_TOKEN ?? config?.primaryApiKey ?? ""));
+        const baseUrl = normalizeBaseUrl(pickFirstText(process.env.CODINGNS_LIGHTWEIGHT_ANTHROPIC_BASE_URL, injectedConfig?.anthropic?.baseUrl, String(env.ANTHROPIC_BASE_URL ?? ""), process.env.ANTHROPIC_BASE_URL, "https://api.anthropic.com") ?? "https://api.anthropic.com");
+        const model = modelOverride
+            || pickFirstText(process.env.CODINGNS_LIGHTWEIGHT_ANTHROPIC_MODEL, injectedConfig?.anthropic?.model, String(env.ANTHROPIC_MODEL ?? ""), DEFAULT_CLAUDE_MODEL)
+            || DEFAULT_CLAUDE_MODEL;
+        if (!key) {
+            throw new AppError({
+                statusCode: 500,
+                errorCode: "ANTHROPIC_LIGHTWEIGHT_AUTH_MISSING",
+                detail: `未找到 Claude Code 轻量会话可用的 API key。优先检查 ~/.claude/settings.json 或 ~/.claude/config.json，或在 ${this.getLightweightRuntimeConfigPath()} 写入 anthropic.apiKey。`
+            });
+        }
+        return {
+            apiKey: key,
+            baseUrl,
+            model
+        };
+    }
+    resolveWorkspaceDir(workspaceId) {
+        return path.join(this.hostDataRootDir, "affairs-lightweight-sessions", workspaceId);
+    }
+    resolveSessionFilePath(workspaceId, sessionId) {
+        return path.join(this.resolveWorkspaceDir(workspaceId), `${sessionId}.json`);
+    }
+    getLightweightRuntimeConfigPath() {
+        return path.join(this.hostDataRootDir, "lightweight-runtime.json");
+    }
+    async readLightweightRuntimeConfigFile() {
+        const configPath = this.getLightweightRuntimeConfigPath();
+        const content = await safeReadTextFile(configPath);
+        if (!content) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(content);
+            return parsed && typeof parsed === "object" ? parsed : null;
+        }
+        catch {
+            throw new AppError({
+                statusCode: 500,
+                errorCode: "LIGHTWEIGHT_RUNTIME_CONFIG_INVALID",
+                detail: `事务轻量会话配置文件不是合法 JSON：${configPath}`
+            });
+        }
+    }
+}
+function validateLightweightProvider(provider) {
+    if (!LIGHTWEIGHT_PROVIDER_IDS.has(provider)) {
+        throw new AppError({
+            statusCode: 400,
+            errorCode: "INVALID_INPUT",
+            detail: "事务轻量会话只支持 Codex 和 Claude Code",
+            field: "provider"
+        });
+    }
+}
+function normalizeClientRequestId(value) {
+    const normalized = value?.trim();
+    return normalized || createId();
+}
+function normalizeOptionalTimestamp(value) {
+    const normalized = value?.trim() ?? "";
+    if (!normalized) {
+        return null;
+    }
+    const parsed = Date.parse(normalized);
+    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+}
+function buildDraftTitle(content) {
+    const singleLine = content.replace(/\s+/g, " ").trim();
+    if (!singleLine) {
+        return "新对话";
+    }
+    return singleLine.length > 24 ? `${singleLine.slice(0, 24)}…` : singleLine;
+}
+function createUserMessage(input) {
+    return {
+        messageId: `lightweight-user-${input.clientRequestId}`,
+        provider: input.provider,
+        providerSessionId: input.providerSessionId,
+        role: "user",
+        kind: "text",
+        content: input.content,
+        toolCall: null,
+        timestamp: input.timestamp,
+        sequence: input.sequence,
+        rawRef: `${input.rawStoreRef}#${input.clientRequestId}`
+    };
+}
+function createAssistantMessage(input) {
+    return {
+        messageId: `lightweight-assistant-${createId()}`,
+        provider: input.provider,
+        providerSessionId: input.providerSessionId,
+        role: "assistant",
+        kind: "text",
+        content: input.content,
+        toolCall: null,
+        timestamp: input.timestamp,
+        sequence: input.sequence,
+        rawRef: `${input.rawStoreRef}#assistant-${input.sequence}`
+    };
+}
+function createToolLifecycleMessage(input) {
+    const content = normalizeText(input.event.detail)
+        || normalizeText(input.event.output)
+        || normalizeText(input.event.input)
+        || input.event.toolName;
+    return {
+        messageId: `lightweight-tool-${input.event.toolCallId}`,
+        provider: input.provider,
+        providerSessionId: input.providerSessionId,
+        role: "tool",
+        kind: input.event.status === "running" ? "tool_call" : "tool_result",
+        content,
+        toolCall: {
+            callId: input.event.toolCallId,
+            name: input.event.toolName,
+            input: input.event.input ?? "",
+            output: input.event.output,
+            error: input.event.status === "failed"
+                ? (normalizeText(input.event.detail) || normalizeText(input.event.output) || null)
+                : null,
+            status: input.event.status
+        },
+        timestamp: input.timestamp,
+        sequence: input.sequence,
+        rawRef: `${input.rawStoreRef}#tool-${input.event.toolCallId}`
+    };
+}
+function upsertToolLifecycleMessage(input) {
+    const timestamp = input.observedAt ?? new Date().toISOString();
+    const existingIndex = input.document.messages.findIndex((message) => {
+        if (message.role !== "tool" || !message.toolCall) {
+            return false;
+        }
+        return message.toolCall.callId === input.event.toolCallId;
+    });
+    if (existingIndex >= 0) {
+        const existing = input.document.messages[existingIndex];
+        const nextMessage = createToolLifecycleMessage({
+            provider: input.document.session.provider,
+            providerSessionId: input.document.session.providerSessionId,
+            timestamp,
+            rawStoreRef: input.document.session.rawStoreRef,
+            sequence: existing.sequence,
+            event: input.event
+        });
+        const nextMessages = [...input.document.messages];
+        nextMessages[existingIndex] = {
+            ...nextMessage,
+            timestamp: existing.timestamp,
+            sequence: existing.sequence,
+            rawRef: existing.rawRef,
+            messageId: existing.messageId
+        };
+        return {
+            ...input.document,
+            messages: nextMessages,
+            session: {
+                ...input.document.session,
+                updatedAt: timestamp,
+                lastEventAt: timestamp,
+                messageCount: nextMessages.length
+            }
+        };
+    }
+    const assistantIndex = input.document.messages.findIndex((message) => message.role === "assistant");
+    const insertAt = assistantIndex >= 0 ? assistantIndex : input.document.messages.length;
+    const sequence = insertAt > 0
+        ? input.document.messages[insertAt - 1].sequence + 1
+        : 1;
+    const nextMessage = createToolLifecycleMessage({
+        provider: input.document.session.provider,
+        providerSessionId: input.document.session.providerSessionId,
+        timestamp,
+        rawStoreRef: input.document.session.rawStoreRef,
+        sequence,
+        event: input.event
+    });
+    const nextMessages = [
+        ...input.document.messages.slice(0, insertAt),
+        nextMessage,
+        ...input.document.messages.slice(insertAt).map((message) => ({
+            ...message,
+            sequence: message.sequence + 1,
+            rawRef: message.role === "assistant"
+                ? `${input.document.session.rawStoreRef}#assistant-${message.sequence + 1}`
+                : message.rawRef
+        }))
+    ];
+    return {
+        ...input.document,
+        messages: nextMessages,
+        session: {
+            ...input.document.session,
+            updatedAt: timestamp,
+            lastEventAt: timestamp,
+            messageCount: nextMessages.length
+        }
+    };
+}
+function normalizeOpenAiReasoning(reasoningLevel) {
+    const normalized = reasoningLevel?.trim().toLowerCase();
+    if (normalized === "low" || normalized === "medium" || normalized === "high") {
+        return { effort: normalized };
+    }
+    if (normalized === "xhigh") {
+        return { effort: "high" };
+    }
+    return { effort: "medium" };
+}
+function createOpenAiResponsesPayload(input) {
+    return {
+        model: input.model,
+        reasoning: normalizeOpenAiReasoning(input.reasoningLevel),
+        tools: [
+            {
+                type: "web_search",
+                user_location: {
+                    type: "approximate",
+                    country: "US"
+                }
+            }
+        ],
+        tool_choice: "auto",
+        include: ["web_search_call.action.sources"],
+        input: [
+            {
+                role: "system",
+                content: LIGHTWEIGHT_SYSTEM_PROMPT
+            },
+            ...input.messages.map((message) => ({
+                role: message.role,
+                content: message.content
+            }))
+        ]
+    };
+}
+function createOpenAiChatPayload(input) {
+    return {
+        model: input.model,
+        messages: [
+            {
+                role: "system",
+                content: LIGHTWEIGHT_SYSTEM_PROMPT
+            },
+            ...input.messages.map((message) => ({
+                role: message.role,
+                content: message.content
+            }))
+        ],
+        temperature: 0.2
+    };
+}
+function extractOpenAiResponseText(body) {
+    return normalizeText(body?.output_text)
+        ?? extractOpenAiOutputText(body?.output)
+        ?? extractOpenAiChoiceText(body);
+}
+function extractOpenAiOutputText(output) {
+    if (!Array.isArray(output)) {
+        return null;
+    }
+    const segments = [];
+    for (const item of output) {
+        if (!item || typeof item !== "object") {
+            continue;
+        }
+        const content = Array.isArray(item.content) ? item.content : [];
+        for (const part of content) {
+            const text = normalizeText(part?.text);
+            if (text) {
+                segments.push(text);
+            }
+        }
+    }
+    return segments.length > 0 ? segments.join("\n\n") : null;
+}
+function extractOpenAiChoiceText(body) {
+    const rawContent = body?.choices?.[0]?.message?.content;
+    if (typeof rawContent === "string") {
+        return normalizeText(rawContent);
+    }
+    if (!Array.isArray(rawContent)) {
+        return null;
+    }
+    const segments = rawContent
+        .map((item) => {
+        if (typeof item === "string") {
+            return item;
+        }
+        return normalizeText(item?.text);
+    })
+        .filter((item) => Boolean(item));
+    return segments.length > 0 ? segments.join("\n\n") : null;
+}
+function extractAnthropicOutputText(content) {
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    const segments = content
+        .map((item) => normalizeText(item?.text))
+        .filter((item) => Boolean(item));
+    return segments.length > 0 ? segments.join("\n\n") : null;
+}
+function normalizeText(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized : null;
+}
+function pickFirstText(...values) {
+    for (const value of values) {
+        const normalized = normalizeText(value);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return null;
+}
+function normalizeBaseUrl(value) {
+    return value.replace(/\/+$/, "");
+}
+async function streamOpenAiSseText(response, onDelta, onTool) {
+    let accumulated = "";
+    await consumeSseResponse(response, async ({ event, data }) => {
+        if (!data || data === "[DONE]") {
+            return;
+        }
+        let payload = null;
+        try {
+            payload = JSON.parse(data);
+        }
+        catch {
+            return;
+        }
+        const toolEvent = extractOpenAiSseToolEvent(event, payload);
+        if (toolEvent) {
+            await onTool?.(toolEvent);
+        }
+        const chunks = extractOpenAiSseDeltaChunks(payload);
+        for (const chunk of chunks) {
+            if (!chunk) {
+                continue;
+            }
+            accumulated += chunk;
+            await onDelta(chunk);
+        }
+    });
+    return normalizeText(accumulated);
+}
+async function streamAnthropicSseText(response, onDelta, onTool) {
+    let accumulated = "";
+    await consumeSseResponse(response, async ({ event, data }) => {
+        if (!data) {
+            return;
+        }
+        let payload = null;
+        try {
+            payload = JSON.parse(data);
+        }
+        catch {
+            return;
+        }
+        const eventType = event || payload?.type;
+        const toolEvent = extractAnthropicSseToolEvent(eventType, payload);
+        if (toolEvent) {
+            await onTool?.(toolEvent);
+        }
+        if (eventType === "content_block_delta" && payload?.delta?.type === "text_delta") {
+            const chunk = normalizeText(payload?.delta?.text);
+            if (chunk) {
+                accumulated += chunk;
+                await onDelta(chunk);
+            }
+            return;
+        }
+        if (eventType === "content_block_start" && payload?.content_block?.type === "text") {
+            const chunk = normalizeText(payload?.content_block?.text);
+            if (chunk) {
+                accumulated += chunk;
+                await onDelta(chunk);
+            }
+        }
+    });
+    return normalizeText(accumulated);
+}
+async function consumeSseResponse(response, onEvent) {
+    const reader = response.body?.getReader();
+    if (!reader) {
+        return;
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentEvent = "";
+    let currentDataLines = [];
+    const flushEvent = async () => {
+        if (!currentEvent && currentDataLines.length === 0) {
+            return;
+        }
+        const payload = {
+            event: currentEvent,
+            data: currentDataLines.join("\n")
+        };
+        currentEvent = "";
+        currentDataLines = [];
+        await onEvent(payload);
+    };
+    while (true) {
+        const next = await reader.read();
+        buffer += decoder.decode(next.value ?? new Uint8Array(), { stream: !next.done });
+        while (true) {
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex < 0) {
+                break;
+            }
+            const rawLine = buffer.slice(0, newlineIndex).replace(/\r$/, "");
+            buffer = buffer.slice(newlineIndex + 1);
+            if (!rawLine) {
+                await flushEvent();
+                continue;
+            }
+            if (rawLine.startsWith(":")) {
+                continue;
+            }
+            if (rawLine.startsWith("event:")) {
+                currentEvent = rawLine.slice("event:".length).trim();
+                continue;
+            }
+            if (rawLine.startsWith("data:")) {
+                currentDataLines.push(rawLine.slice("data:".length).trimStart());
+            }
+        }
+        if (next.done) {
+            break;
+        }
+    }
+    if (buffer.trim()) {
+        const trailingLine = buffer.replace(/\r$/, "");
+        if (trailingLine.startsWith("data:")) {
+            currentDataLines.push(trailingLine.slice("data:".length).trimStart());
+        }
+    }
+    await flushEvent();
+}
+function extractOpenAiSseDeltaChunks(payload) {
+    const chunks = [];
+    const responseDelta = normalizeText(payload?.delta);
+    if (responseDelta) {
+        chunks.push(responseDelta);
+    }
+    const outputTextDelta = normalizeText(payload?.text);
+    if (payload?.type === "response.output_text.delta" && outputTextDelta) {
+        chunks.push(outputTextDelta);
+    }
+    const chatDelta = payload?.choices?.[0]?.delta?.content;
+    if (typeof chatDelta === "string" && chatDelta.trim().length > 0) {
+        chunks.push(chatDelta);
+    }
+    return chunks;
+}
+function extractOpenAiSseToolEvent(eventName, payload) {
+    const payloadType = normalizeText(payload?.type) ?? "";
+    const resolvedEvent = normalizeText(eventName) ?? payloadType;
+    const isDirectWebSearchEvent = resolvedEvent.includes("web_search_call");
+    const isOutputItemWebSearchEvent = resolvedEvent === "response.output_item.done"
+        && normalizeText(payload?.item?.type) === "web_search_call";
+    const isOutputItemAddedWebSearchEvent = resolvedEvent === "response.output_item.added"
+        && normalizeText(payload?.item?.type) === "web_search_call";
+    if (!isDirectWebSearchEvent && !isOutputItemWebSearchEvent && !isOutputItemAddedWebSearchEvent) {
+        return null;
+    }
+    const toolCallId = normalizeText(payload?.item_id)
+        || normalizeText(payload?.item?.id)
+        || normalizeText(payload?.call_id)
+        || normalizeText(payload?.id)
+        || "web_search";
+    const status = isOutputItemWebSearchEvent
+        ? "completed"
+        : resolvedEvent.endsWith(".completed")
+            ? "completed"
+            : resolvedEvent.endsWith(".failed")
+                ? "failed"
+                : "running";
+    const sources = readWebSearchSources(payload);
+    const sourceCount = sources.length;
+    const input = readWebSearchQuery(payload);
+    const detail = status === "completed"
+        ? (sourceCount > 0 ? `联网搜索完成，找到 ${sourceCount} 个来源` : "联网搜索完成")
+        : status === "failed"
+            ? normalizeText(payload?.error?.message) || "联网搜索失败"
+            : resolvedEvent.endsWith(".searching")
+                ? "正在联网搜索"
+                : "正在准备联网搜索";
+    return {
+        type: "tool",
+        toolCallId,
+        toolName: "web_search",
+        status,
+        detail,
+        input,
+        output: status === "completed"
+            ? JSON.stringify({
+                detail,
+                query: input,
+                sources
+            }, null, 2)
+            : status === "failed"
+                ? detail
+                : null
+    };
+}
+function extractAnthropicSseToolEvent(eventType, payload) {
+    const block = payload?.content_block;
+    const delta = payload?.delta;
+    const blockType = normalizeText(block?.type) ?? normalizeText(delta?.type) ?? "";
+    const toolName = normalizeText(block?.name)
+        || normalizeText(payload?.name)
+        || normalizeText(delta?.name)
+        || (blockType.includes("web_search") ? "web_search" : null);
+    if (toolName !== "web_search") {
+        return null;
+    }
+    const status = eventType === "content_block_stop" || eventType === "message_stop"
+        ? "completed"
+        : eventType === "error"
+            ? "failed"
+            : "running";
+    const input = readWebSearchQuery(payload);
+    const sources = readWebSearchSources(payload);
+    const detail = status === "completed"
+        ? (sources.length > 0 ? `联网搜索完成，找到 ${sources.length} 个来源` : "联网搜索完成")
+        : status === "failed"
+            ? normalizeText(payload?.error?.message) || "联网搜索失败"
+            : "正在联网搜索";
+    return {
+        type: "tool",
+        toolCallId: normalizeText(block?.id) || normalizeText(payload?.id) || normalizeText(delta?.id) || "web_search",
+        toolName,
+        status,
+        detail,
+        input,
+        output: status === "completed"
+            ? JSON.stringify({
+                detail,
+                query: input,
+                sources
+            }, null, 2)
+            : status === "failed"
+                ? detail
+                : null
+    };
+}
+function readSourceCount(payload) {
+    return readWebSearchSources(payload).length;
+}
+function readWebSearchQuery(payload) {
+    return pickFirstText(payload?.action?.query, payload?.action?.search_query, payload?.item?.action?.query, payload?.item?.action?.search_query, payload?.item?.query, payload?.query, payload?.search_query, payload?.input, payload?.arguments?.query, payload?.arguments?.search_query, payload?.content_block?.input?.query, payload?.content_block?.input?.search_query, payload?.delta?.partial_json, payload?.result?.query, payload?.web_search?.query);
+}
+function flattenWebSearchSourceCandidates(payload) {
+    const candidates = [
+        payload?.action?.sources,
+        payload?.item?.action?.sources,
+        payload?.item?.sources,
+        payload?.sources,
+        payload?.result?.sources,
+        payload?.web_search?.sources,
+        payload?.content_block?.results,
+        payload?.content_block?.sources,
+        payload?.results
+    ];
+    for (const candidate of candidates) {
+        if (Array.isArray(candidate) && candidate.length > 0) {
+            return candidate;
+        }
+    }
+    return [];
+}
+function readWebSearchSources(payload) {
+    return flattenWebSearchSourceCandidates(payload)
+        .map((item) => ({
+        title: pickFirstText(item?.title, item?.name, item?.text),
+        url: pickFirstText(item?.url, item?.link, item?.uri)
+    }))
+        .filter((item) => item.title || item.url)
+        .slice(0, 8);
+}
+async function safeReadTextFile(filePath) {
+    try {
+        return await fs.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+async function readJsonFile(filePath) {
+    const content = await safeReadTextFile(filePath);
+    if (!content) {
+        return {};
+    }
+    return JSON.parse(content);
+}
+function parseCodexTomlConfig(content) {
+    if (!content) {
+        return { model: null, baseUrl: null };
+    }
+    const model = matchTomlString(content, /^model\s*=\s*"([^"]+)"/m);
+    const providerId = matchTomlString(content, /^model_provider\s*=\s*"([^"]+)"/m);
+    if (!providerId) {
+        return { model, baseUrl: null };
+    }
+    const marker = `[model_providers.${JSON.stringify(providerId).slice(1, -1)}]`;
+    const sectionStart = content.indexOf(marker);
+    if (sectionStart < 0) {
+        return { model, baseUrl: null };
+    }
+    const nextSection = content.indexOf("\n[", sectionStart + marker.length);
+    const section = nextSection >= 0 ? content.slice(sectionStart, nextSection) : content.slice(sectionStart);
+    const baseUrl = matchTomlString(section, /^base_url\s*=\s*"([^"]+)"/m);
+    return { model, baseUrl };
+}
+function matchTomlString(content, pattern) {
+    const matched = content.match(pattern);
+    return matched?.[1]?.trim() || null;
+}
+async function safeReadDir(dirPath) {
+    try {
+        return await fs.readdir(dirPath, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+}
+async function postJsonWithFallbacks(input) {
+    let lastResponse = null;
+    for (const candidate of input.pathCandidates) {
+        const url = buildRequestUrl(input.baseUrl, candidate);
+        const response = await fetch(url, input.init);
+        if (response.status !== 404) {
+            return response;
+        }
+        lastResponse = response;
+    }
+    if (lastResponse) {
+        return lastResponse;
+    }
+    throw new AppError({
+        statusCode: 502,
+        errorCode: "LIGHTWEIGHT_RUNTIME_UNREACHABLE",
+        detail: "轻量会话上游地址不可达"
+    });
+}
+function buildRequestUrl(baseUrl, candidate) {
+    const normalizedBase = normalizeBaseUrl(baseUrl);
+    const normalizedPath = candidate.replace(/^\/+/, "");
+    return `${normalizedBase}/${normalizedPath}`;
+}
+function inferSessionIdFromSessionFilePath(filePath) {
+    const baseName = path.basename(filePath);
+    if (!baseName.endsWith(".json")) {
+        return null;
+    }
+    const sessionId = baseName.slice(0, -".json".length).trim();
+    return sessionId || null;
+}
+function cloneSessionDocument(document) {
+    return {
+        ...document,
+        session: {
+            ...document.session
+        },
+        messages: document.messages.map((message) => ({
+            ...message,
+            toolCall: message.toolCall
+                ? {
+                    ...message.toolCall
+                }
+                : null
+        }))
+    };
+}
+function shouldRetrySessionDocumentRead(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return error instanceof SyntaxError || /Unexpected end of JSON input/i.test(error.message);
+}
+async function sleep(timeoutMs) {
+    await new Promise((resolve) => {
+        setTimeout(resolve, timeoutMs);
+    });
+}
+async function parseJsonResponse(response) {
+    const text = await response.text();
+    if (!text.trim()) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { raw: text };
+    }
+}
+function createUpstreamError(code, body, status) {
+    return new AppError({
+        statusCode: 502,
+        errorCode: code,
+        detail: normalizeText(body?.error?.message)
+            || normalizeText(body?.error?.detail)
+            || normalizeText(body?.detail)
+            || normalizeText(body?.raw)
+            || `上游轻量会话接口返回 ${status}`
+    });
+}
+function getErrorMessage(error) {
+    if (error instanceof AppError) {
+        return error.message;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return "未知错误";
+}
+//# sourceMappingURL=affairs-lightweight-session-service.js.map