@vibe-lark/larkpal 0.1.56 → 0.1.57

package/dist/main.mjs

@@ -3637,18 +3637,93 @@ function summarizeString(value) {
 *   DELETE /api/chat/sessions/:id     — 删除会话
 */
 const log$28 = larkLogger("chat/stream");
-const activeStreamSessions = /* @__PURE__ */ new Set();
+const chatRunsBySession = /* @__PURE__ */ new Map();
 /** 统一写 SSE 格式数据到响应流 */
 function sendSSE(res, event, data) {
 	const payload = typeof data === "string" ? data : JSON.stringify(data);
 	res.write(`event: ${event}\ndata: ${payload}\n\n`);
 }
 function isChatSessionRunning(sessionId, processManager) {
-	return activeStreamSessions.has(sessionId) || (processManager.isSessionBusy?.(sessionId) ?? false);
+	return getActiveChatRun(sessionId) != null || (processManager.isSessionBusy?.(sessionId) ?? false);
 }
 function logChatAudit(event) {
 	log$28.info("[stream] Agent audit event", { ...event });
 }
+function prepareSSE(res) {
+	res.setHeader("Content-Type", "text/event-stream");
+	res.setHeader("Cache-Control", "no-cache");
+	res.setHeader("Connection", "keep-alive");
+	res.setHeader("X-Accel-Buffering", "no");
+	res.flushHeaders();
+}
+function getActiveChatRun(sessionId) {
+	const run = chatRunsBySession.get(sessionId);
+	return run?.status === "running" ? run : void 0;
+}
+function serializeChatRun(run) {
+	return {
+		runId: run.runId,
+		sessionId: run.sessionId,
+		requestId: run.requestId,
+		traceId: run.traceId,
+		scenarioId: run.scenarioId,
+		status: run.status,
+		startedAt: run.startedAt,
+		completedAt: run.completedAt,
+		finalStatus: run.finalStatus,
+		error: run.error,
+		textLength: run.text.length
+	};
+}
+function isRunVisibleToUser(run, params) {
+	return run.tenantKey === params.tenantKey && run.openId === params.openId;
+}
+function addRunClient(req, res, run) {
+	run.clients.add(res);
+	req.on("close", () => {
+		run.clients.delete(res);
+		log$28.info("[stream] 客户端断开连接", {
+			sessionId: run.sessionId,
+			runId: run.runId
+		});
+	});
+}
+function sendRunStatus(res, run) {
+	sendSSE(res, "run-status", serializeChatRun(run));
+}
+function broadcastRunEvent(run, event, data) {
+	for (const client of Array.from(run.clients)) try {
+		sendSSE(client, event, data);
+	} catch (err) {
+		run.clients.delete(client);
+		log$28.warn("[stream] SSE 写入失败，移除客户端", {
+			sessionId: run.sessionId,
+			runId: run.runId,
+			error: err instanceof Error ? err.message : String(err)
+		});
+	}
+}
+function broadcastRunStatus(run) {
+	broadcastRunEvent(run, "run-status", serializeChatRun(run));
+}
+function endRunClients(run) {
+	for (const client of Array.from(run.clients)) try {
+		client.end();
+	} catch {}
+	run.clients.clear();
+}
+function queueRunMessage(run, messageStore, message, label) {
+	run.persistQueue = run.persistQueue.catch(() => void 0).then(async () => {
+		await messageStore.appendMessage(message);
+	}).catch((err) => {
+		log$28.error(label, {
+			sessionId: run.sessionId,
+			runId: run.runId,
+			error: err instanceof Error ? err.message : String(err)
+		});
+	});
+	return run.persistQueue;
+}
 function buildRuntimeEventMessageMetadata(event, runtimeConfig) {
 	return {
 		runtimeEventType: event.type,
@@ -3686,22 +3761,42 @@ function createChatRouter(config) {
 	router.post("/api/chat/stream", chatAuthMiddleware, async (req, res) => {
 		const { userId, openId, tenantKey } = res.locals.chatUser;
 		const body = req.body;
-		if (!body.prompt || typeof body.prompt !== "string") {
-			res.status(400).json({ error: "prompt is required and must be a string" });
-			return;
-		}
 		if (!tenantKey || !userId || !openId) {
 			res.status(401).json({ error: "Missing required chat identity: tenantKey, userId, openId" });
 			return;
 		}
 		const requestId = getGatewayRequestId(req.headers);
 		const traceId = getGatewayTraceId(req.headers, requestId);
+		let sessionId = body.session_id;
+		const activeRun = sessionId ? getActiveChatRun(sessionId) : void 0;
+		if (activeRun) {
+			if (!isRunVisibleToUser(activeRun, {
+				tenantKey,
+				openId
+			})) {
+				res.status(403).json({ error: "Forbidden" });
+				return;
+			}
+			prepareSSE(res);
+			addRunClient(req, res, activeRun);
+			sendSSE(res, "session", { sessionId });
+			sendRunStatus(res, activeRun);
+			log$28.info("[stream] 已重新连接到运行中的 run", {
+				sessionId,
+				runId: activeRun.runId
+			});
+			return;
+		}
+		if (!body.prompt || typeof body.prompt !== "string") {
+			res.status(400).json({ error: "prompt is required and must be a string" });
+			return;
+		}
 		const scenarioId = getScenarioId(body.options?.scenarioId, body.options?.metadata);
 		const attachments = getRunInputValue(body.attachments, body.options?.attachments, body.options?.metadata?.attachments);
 		const sourceArtifacts = getRunInputValue(body.sourceArtifacts, body.source_artifacts, body.options?.sourceArtifacts, body.options?.source_artifacts, body.options?.metadata?.sourceArtifacts, body.options?.metadata?.source_artifacts);
 		log$28.info("[stream] 收到流式对话请求", {
 			userId,
-			sessionId: body.session_id,
+			sessionId,
 			requestId,
 			traceId,
 			scenarioId,
@@ -3709,7 +3804,6 @@ function createChatRouter(config) {
 			hasSourceArtifacts: sourceArtifacts !== void 0,
 			promptLength: body.prompt.length
 		});
-		let sessionId = body.session_id;
 		if (!sessionId) {
 			sessionId = (await messageStore.createSession({
 				id: `client_${openId}_${Date.now().toString(36)}`,
@@ -3723,22 +3817,85 @@ function createChatRouter(config) {
 			});
 		}
 		if (isChatSessionRunning(sessionId, processManager)) {
-			log$28.warn("[stream] session 正在运行，拒绝并发请求", {
+			log$28.warn("[stream] session 正在被非 Web Chat run 占用", {
 				tenantKey,
 				userId,
 				sessionId
 			});
-			res.setHeader("Content-Type", "text/event-stream");
-			res.setHeader("Cache-Control", "no-cache");
-			res.setHeader("Connection", "keep-alive");
-			res.setHeader("X-Accel-Buffering", "no");
-			res.flushHeaders();
+			prepareSSE(res);
 			sendSSE(res, "session", { sessionId });
 			sendSSE(res, "error", { message: `Session ${sessionId} is already running` });
 			res.end();
 			return;
 		}
-		activeStreamSessions.add(sessionId);
+		const runtimeConfig = buildAgentRuntimeConfig({
+			requestId,
+			traceId,
+			sessionId,
+			conversationId: sessionId,
+			entrypoint: "chat",
+			scenarioId,
+			prompt: body.prompt,
+			maxTurns: body.options?.maxTurns,
+			maxBudgetUsd: body.options?.maxBudgetUsd,
+			model: process.env.CLAUDE_MODEL || void 0,
+			attachments,
+			sourceArtifacts,
+			policy: body.options?.policy,
+			metadata: body.options?.metadata,
+			identity: {
+				tenantKey,
+				userId,
+				openId,
+				userName: userId
+			}
+		});
+		const run = {
+			runId: requestId,
+			sessionId,
+			requestId,
+			traceId,
+			scenarioId,
+			tenantKey,
+			userId,
+			openId,
+			status: "running",
+			startedAt: Date.now(),
+			text: "",
+			clients: /* @__PURE__ */ new Set(),
+			runtimeConfig,
+			persistQueue: Promise.resolve()
+		};
+		const appendRunStatusMessage = () => {
+			return queueRunMessage(run, messageStore, {
+				sessionId,
+				role: "tool",
+				content: JSON.stringify({
+					runtimeEventType: "run-status",
+					run: serializeChatRun(run)
+				}),
+				channel: "web",
+				metadata: {
+					runId: run.runId,
+					requestId,
+					traceId,
+					scenarioId,
+					runtimeEventType: "run-status",
+					finalStatus: run.finalStatus,
+					errorMessage: run.error
+				}
+			}, "[stream] 保存 run status 消息失败");
+		};
+		const markRunTerminal = async (status, params) => {
+			if (run.status !== "running") return false;
+			run.status = status;
+			run.completedAt = Date.now();
+			run.finalStatus = params.finalStatus;
+			run.error = params.error;
+			broadcastRunStatus(run);
+			await appendRunStatusMessage();
+			return true;
+		};
 		try {
 			await messageStore.appendMessage({
 				sessionId,
@@ -3746,6 +3903,7 @@ function createChatRouter(config) {
 				content: body.prompt,
 				channel: "web",
 				metadata: {
+					runId: run.runId,
 					requestId,
 					traceId,
 					scenarioId,
@@ -3756,7 +3914,6 @@ function createChatRouter(config) {
 				}
 			});
 		} catch (err) {
-			activeStreamSessions.delete(sessionId);
 			const errorMessage = err instanceof Error ? err.message : String(err);
 			log$28.error("[stream] 保存用户消息失败", {
 				sessionId,
@@ -3765,34 +3922,12 @@ function createChatRouter(config) {
 			res.status(500).json({ error: "Failed to append user message" });
 			return;
 		}
-		res.setHeader("Content-Type", "text/event-stream");
-		res.setHeader("Cache-Control", "no-cache");
-		res.setHeader("Connection", "keep-alive");
-		res.setHeader("X-Accel-Buffering", "no");
-		res.flushHeaders();
+		chatRunsBySession.set(sessionId, run);
+		appendRunStatusMessage();
+		prepareSSE(res);
+		addRunClient(req, res, run);
 		sendSSE(res, "session", { sessionId });
-		const runtimeConfig = buildAgentRuntimeConfig({
-			requestId,
-			traceId,
-			sessionId,
-			conversationId: sessionId,
-			entrypoint: "chat",
-			scenarioId,
-			prompt: body.prompt,
-			maxTurns: body.options?.maxTurns,
-			maxBudgetUsd: body.options?.maxBudgetUsd,
-			model: process.env.CLAUDE_MODEL || void 0,
-			attachments,
-			sourceArtifacts,
-			policy: body.options?.policy,
-			metadata: body.options?.metadata,
-			identity: {
-				tenantKey,
-				userId,
-				openId,
-				userName: userId
-			}
-		});
+		sendRunStatus(res, run);
 		const handleBlockedEvent = (event) => {
 			const sanitized = sanitizeBlockedEvent(event);
 			log$28.warn("[stream] Agent blocked event", { ...sanitized });
@@ -3802,24 +3937,35 @@ function createChatRouter(config) {
 				errorCode: sanitized.reasonCode,
 				errorMessage: sanitized.reason,
 				metadata: {
+					runId: run.runId,
 					traceId,
 					reasonCode: sanitized.reasonCode
 				}
 			}));
+			queueRunMessage(run, messageStore, {
+				sessionId,
+				role: "tool",
+				content: JSON.stringify({ blocked: sanitized }),
+				channel: "web",
+				metadata: {
+					runId: run.runId,
+					requestId,
+					traceId,
+					scenarioId,
+					runtimeEventType: "blocked",
+					toolName: sanitized.name,
+					reasonCode: sanitized.reasonCode
+				}
+			}, "[stream] 保存 blocked 消息失败");
+			broadcastRunEvent(run, "blocked", { event: sanitized });
 		};
-		let accumText = "";
-		let clientDisconnected = false;
-		req.on("close", () => {
-			clientDisconnected = true;
-			log$28.info("[stream] 客户端断开连接", { sessionId });
-		});
 		const handleRuntimeEvent = (event) => {
 			const eventSummary = summarizeForAudit(event);
 			if (runtimeConfig.requestContext) logChatAudit(buildAuditEvent(runtimeConfig.requestContext, "runtime_event", {
 				resultSummary: eventSummary,
 				metadata: buildRuntimeEventAuditMetadata(event)
 			}));
-			messageStore.appendMessage({
+			queueRunMessage(run, messageStore, {
 				sessionId,
 				role: "tool",
 				content: JSON.stringify({
@@ -3827,47 +3973,47 @@ function createChatRouter(config) {
 					event: eventSummary
 				}),
 				channel: "web",
-				metadata: buildRuntimeEventMessageMetadata(event, runtimeConfig)
-			}).catch((err) => {
-				log$28.error("[stream] 保存 runtime event 消息失败", {
-					sessionId,
-					error: err
-				});
-			});
-			if (!clientDisconnected) sendSSE(res, "runtime-event", {
+				metadata: {
+					...buildRuntimeEventMessageMetadata(event, runtimeConfig),
+					runId: run.runId
+				}
+			}, "[stream] 保存 runtime event 消息失败");
+			broadcastRunEvent(run, "runtime-event", {
 				type: event.type,
 				event: eventSummary
 			});
 		};
 		const callbacks = {
 			onTextDelta: (text) => {
-				accumText += text;
-				if (!clientDisconnected) sendSSE(res, "text-delta", { text });
+				run.text += text;
+				broadcastRunEvent(run, "text-delta", { text });
 			},
 			onThinkingDelta: (text) => {
-				if (!clientDisconnected) sendSSE(res, "thinking-delta", { text });
+				broadcastRunEvent(run, "thinking-delta", { text });
 			},
 			onToolUseStart: (toolName, toolInput) => {
 				if (runtimeConfig.requestContext) logChatAudit(buildAuditEvent(runtimeConfig.requestContext, "tool_call_started", {
 					toolName,
 					inputSummary: summarizeForAudit(toolInput)
 				}));
-				messageStore.appendMessage({
+				queueRunMessage(run, messageStore, {
 					sessionId,
 					role: "tool",
 					content: JSON.stringify({
 						toolName,
-						input: toolInput
+						input: summarizeForAudit(toolInput)
 					}),
 					channel: "web",
-					metadata: { toolName }
-				}).catch((err) => {
-					log$28.error("[stream] 保存 tool 消息失败", {
-						sessionId,
-						error: err
-					});
-				});
-				if (!clientDisconnected) sendSSE(res, "tool-use-start", {
+					metadata: {
+						runId: run.runId,
+						requestId,
+						traceId,
+						scenarioId,
+						runtimeEventType: "tool-use-start",
+						toolName
+					}
+				}, "[stream] 保存 tool 消息失败");
+				broadcastRunEvent(run, "tool-use-start", {
 					toolName,
 					input: toolInput
 				});
@@ -3879,62 +4025,80 @@ function createChatRouter(config) {
 					resultSummary,
 					metadata: buildToolResultAuditMetadata(result)
 				}));
-				if (!clientDisconnected) sendSSE(res, "tool-result", {
+				queueRunMessage(run, messageStore, {
+					sessionId,
+					role: "tool",
+					content: JSON.stringify({
+						toolUseId,
+						result: resultSummary
+					}),
+					channel: "web",
+					metadata: {
+						runId: run.runId,
+						requestId,
+						traceId,
+						scenarioId,
+						runtimeEventType: "tool-result",
+						toolCallId: toolUseId,
+						toolResult: resultSummary
+					}
+				}, "[stream] 保存 tool result 消息失败");
+				broadcastRunEvent(run, "tool-result", {
 					toolUseId,
 					result: resultSummary
 				});
 			},
 			onToolProgress: (toolName, elapsedSeconds) => {
-				if (!clientDisconnected) sendSSE(res, "tool-progress", {
+				broadcastRunEvent(run, "tool-progress", {
 					toolName,
 					elapsedSeconds
 				});
 			},
 			onTurnEnd: (stopReason) => {
 				if (runtimeConfig.requestContext) logChatAudit(buildAuditEvent(runtimeConfig.requestContext, "turn_finished", { metadata: { stopReason } }));
-				if (!clientDisconnected) sendSSE(res, "turn-end", { stopReason });
+				broadcastRunEvent(run, "turn-end", { stopReason });
 			},
 			onResult: async (result) => {
-				try {
-					await messageStore.appendMessage({
-						sessionId,
-						role: "assistant",
-						content: accumText,
-						channel: "web",
-						metadata: {
-							triggeredBy: "web",
-							durationMs: result.durationMs,
-							numTurns: result.numTurns,
-							traceId,
-							requestId
-						}
-					});
-				} catch (err) {
-					log$28.error("[stream] 保存 assistant 消息失败", {
-						sessionId,
-						error: err
-					});
-				}
-				if (!clientDisconnected) {
-					sendSSE(res, "done", {
-						sessionId,
-						result: result.subtype,
-						text: accumText,
+				const finalText = run.text || result.result || "";
+				await queueRunMessage(run, messageStore, {
+					sessionId,
+					role: "assistant",
+					content: finalText,
+					channel: "web",
+					metadata: {
+						runId: run.runId,
+						triggeredBy: "web",
 						durationMs: result.durationMs,
-						totalCostUsd: result.totalCostUsd,
-						numTurns: result.numTurns
-					});
-					res.end();
-				}
+						numTurns: result.numTurns,
+						traceId,
+						requestId,
+						scenarioId,
+						finalStatus: result.subtype,
+						isError: result.isError
+					}
+				}, "[stream] 保存 assistant 消息失败");
+				await markRunTerminal(result.isError ? "failed" : "completed", { finalStatus: result.subtype });
+				broadcastRunEvent(run, "done", {
+					sessionId,
+					runId: run.runId,
+					result: result.subtype,
+					text: finalText,
+					durationMs: result.durationMs,
+					totalCostUsd: result.totalCostUsd,
+					numTurns: result.numTurns
+				});
+				endRunClients(run);
 				log$28.info("[stream] 对话完成", {
 					sessionId,
+					runId: run.runId,
 					result: result.subtype,
-					textLength: accumText.length,
+					textLength: finalText.length,
 					durationMs: result.durationMs
 				});
 				if (runtimeConfig.requestContext) logChatAudit(buildAuditEvent(runtimeConfig.requestContext, "run_finished", {
 					durationMs: result.durationMs,
 					metadata: {
+						runId: run.runId,
 						subtype: result.subtype,
 						totalCostUsd: result.totalCostUsd,
 						numTurns: result.numTurns,
@@ -3945,22 +4109,45 @@ function createChatRouter(config) {
 					}
 				}));
 			},
-			onError: (error) => {
+			onError: async (error) => {
 				log$28.error("[stream] Runtime 执行出错", {
 					sessionId,
+					runId: run.runId,
 					error: error.message
 				});
+				await queueRunMessage(run, messageStore, {
+					sessionId,
+					role: "assistant",
+					content: error.message,
+					channel: "web",
+					metadata: {
+						runId: run.runId,
+						triggeredBy: "web",
+						traceId,
+						requestId,
+						scenarioId,
+						finalStatus: "error",
+						isError: true,
+						errorMessage: error.message
+					}
+				}, "[stream] 保存 error 消息失败");
 				if (runtimeConfig.requestContext) logChatAudit(buildAuditEvent(runtimeConfig.requestContext, "error", {
 					errorMessage: error.message,
 					metadata: {
+						runId: run.runId,
 						traceId,
 						requestId
 					}
 				}));
-				if (!clientDisconnected) {
-					sendSSE(res, "error", { message: error.message });
-					res.end();
-				}
+				await markRunTerminal("failed", {
+					finalStatus: "error",
+					error: error.message
+				});
+				broadcastRunEvent(run, "error", {
+					runId: run.runId,
+					message: error.message
+				});
+				endRunClients(run);
 			},
 			onAuditEvent: (event) => {
 				logChatAudit({
@@ -3975,7 +4162,21 @@ function createChatRouter(config) {
 					resultSummary,
 					metadata: buildVerifierAuditMetadata(result)
 				}));
-				if (!clientDisconnected) sendSSE(res, "verifier-result", { result: resultSummary });
+				queueRunMessage(run, messageStore, {
+					sessionId,
+					role: "tool",
+					content: JSON.stringify({ verifierResult: resultSummary }),
+					channel: "web",
+					metadata: {
+						runId: run.runId,
+						requestId,
+						traceId,
+						scenarioId,
+						runtimeEventType: "verifier-result",
+						verifierResult: resultSummary
+					}
+				}, "[stream] 保存 verifier result 消息失败");
+				broadcastRunEvent(run, "verifier-result", { result: resultSummary });
 			},
 			onRuntimeEvent: handleRuntimeEvent,
 			onScenarioEvent: handleRuntimeEvent,
@@ -3984,6 +4185,7 @@ function createChatRouter(config) {
 		};
 		try {
 			if (runtimeConfig.requestContext) logChatAudit(buildAuditEvent(runtimeConfig.requestContext, "run_started", { metadata: {
+				runId: run.runId,
 				cwd: runtimeConfig.cwd,
 				maxTurns: runtimeConfig.maxTurns,
 				maxBudgetUsd: runtimeConfig.maxBudgetUsd,
@@ -3996,21 +4198,34 @@ function createChatRouter(config) {
 			} }));
 			log$28.info("[stream] 开始执行 prompt", {
 				sessionId,
+				runId: run.runId,
 				cwd: runtimeConfig.cwd
 			});
 			await processManager.executePrompt(runtimeConfig, callbacks);
+			if (run.status === "running") {
+				const errorMessage = "Runtime completed without a final result event";
+				log$28.error("[stream] executePrompt 未返回终态回调", {
+					sessionId,
+					runId: run.runId
+				});
+				await markRunTerminal("failed", {
+					finalStatus: "error",
+					error: errorMessage
+				});
+				broadcastRunEvent(run, "error", {
+					runId: run.runId,
+					message: errorMessage
+				});
+				endRunClients(run);
+			}
 		} catch (err) {
 			const errorMessage = err instanceof Error ? err.message : String(err);
 			log$28.error("[stream] executePrompt 异常", {
 				sessionId,
+				runId: run.runId,
 				error: errorMessage
 			});
-			if (!clientDisconnected) {
-				sendSSE(res, "error", { message: errorMessage });
-				res.end();
-			}
-		} finally {
-			activeStreamSessions.delete(sessionId);
+			if (run.status === "running") await callbacks.onError?.(err instanceof Error ? err : new Error(errorMessage));
 		}
 	});
 	router.get("/api/chat/history", chatAuthMiddleware, async (req, res) => {
@@ -4033,10 +4248,17 @@ function createChatRouter(config) {
 				cursor,
 				limit
 			});
+			const run = chatRunsBySession.get(sessionId);
+			const visibleRun = run && isRunVisibleToUser(run, {
+				tenantKey: chatUser.tenantKey,
+				openId: chatUser.openId
+			}) ? run : void 0;
 			res.json({
 				messages: result.messages,
 				nextCursor: result.nextCursor,
-				sessionId
+				sessionId,
+				activeRun: visibleRun?.status === "running" ? serializeChatRun(visibleRun) : null,
+				latestRun: visibleRun ? serializeChatRun(visibleRun) : null
 			});
 		} catch (err) {
 			const errorMessage = err instanceof Error ? err.message : String(err);
@@ -4047,6 +4269,32 @@ function createChatRouter(config) {
 			res.status(500).json({ error: "Failed to fetch history" });
 		}
 	});
+	router.get("/api/chat/runs", chatAuthMiddleware, async (req, res) => {
+		const chatUser = res.locals.chatUser;
+		const sessionId = req.query.session_id;
+		if (!sessionId) {
+			res.status(400).json({ error: "session_id is required" });
+			return;
+		}
+		const run = chatRunsBySession.get(sessionId);
+		if (!run || !isRunVisibleToUser(run, {
+			tenantKey: chatUser.tenantKey,
+			openId: chatUser.openId
+		})) {
+			res.json({
+				sessionId,
+				run: null,
+				activeRun: null
+			});
+			return;
+		}
+		const serialized = serializeChatRun(run);
+		res.json({
+			sessionId,
+			run: serialized,
+			activeRun: run.status === "running" ? serialized : null
+		});
+	});
 	router.get("/api/chat/sessions", chatAuthMiddleware, async (_req, res) => {
 		const chatUser = res.locals.chatUser;
 		log$28.info("[sessions] 列出用户会话", { userId: chatUser.userId });
@@ -4096,6 +4344,7 @@ function createChatRouter(config) {
 		});
 		try {
 			await messageStore.deleteSession(sessionId);
+			chatRunsBySession.delete(sessionId);
 			res.json({ success: true });
 		} catch (err) {
 			const errorMessage = err instanceof Error ? err.message : String(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-lark/larkpal",
-  "version": "0.1.56",
+  "version": "0.1.57",
   "description": "LarkPal - Lark/Feishu bot service",
   "type": "module",
   "main": "./dist/main.mjs",