@musnows/scriverse 1.0.1 → 1.0.3

package/dist/app.js

@@ -504,6 +504,7 @@ const modelSchema = z.object({
 });
 const aiPromptSchema = z.object({
     systemPrompt: z.string().max(100_000).optional(),
+    systemPromptOverride: z.boolean().optional(),
     imageToolModelId: identifier.nullable().optional(),
     streamIdleTimeoutSeconds: z.number().int().min(MIN_AI_STREAM_IDLE_TIMEOUT_SECONDS).max(MAX_AI_STREAM_IDLE_TIMEOUT_SECONDS).optional()
 });
@@ -639,6 +640,7 @@ const aiProcessStepSchema = z.discriminatedUnion("type", [
 ]);
 const workAiSettingsSchema = z.object({
     systemPrompt: z.string().max(100_000).optional(),
+    systemPromptOverride: z.boolean().optional(),
     dailyTokenQuota: z.number().int().min(1, "Token 额度必须设置大于 0").max(2_000_000_000).nullable().optional(),
     monthlyTokenQuota: z.number().int().min(1, "Token 额度必须设置大于 0").max(2_000_000_000).nullable().optional(),
     autoRunEnabled: z.boolean().optional(),
@@ -3566,7 +3568,7 @@ export function createRuntime(options) {
     app.get("/api/works/:workId/ai/questions/:questionId", (request, response) => {
         data(response, aiWritePlanManager.getQuestion(request.params.questionId, request.params.workId, planViewer()));
     });
-    const resumeQuestionWorkflow = async (questionId, workId, viewer) => {
+    const resumeQuestionWorkflow = async (questionId, workId, viewer, stream = {}) => {
         const continuation = aiWritePlanManager.claimQuestionContinuation(questionId, workId, viewer);
         if (!continuation)
             return;
@@ -3597,26 +3599,88 @@ export function createRuntime(options) {
                     : {}),
                 ...(typeof continuation.round === "number" ? { round: continuation.round } : {}),
                 ...(Array.isArray(continuation.toolMessages) ? { toolMessages: continuation.toolMessages } : {})
-            });
+            }, stream);
             aiWritePlanManager.finishQuestionContinuation(questionId, { callId: resumed.callId ?? null, completed: true });
+            return resumed;
         }
         catch (error) {
             aiWritePlanManager.finishQuestionContinuation(questionId, { message: error instanceof Error ? error.message : "恢复失败" }, true);
             throw error;
         }
     };
+    const respondWithQuestionContinuation = async (request, response, viewer) => {
+        const { questionId, workId } = request.params;
+        if (!request.get("Accept")?.includes("text/event-stream")) {
+            await resumeQuestionWorkflow(questionId, workId, viewer);
+            data(response, aiWritePlanManager.getQuestion(questionId, workId, viewer));
+            return;
+        }
+        const controller = new AbortController();
+        response.status(200);
+        response.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+        response.setHeader("Cache-Control", "no-cache, no-transform");
+        response.setHeader("Connection", "keep-alive");
+        response.setHeader("X-Accel-Buffering", "no");
+        response.flushHeaders();
+        const sendEvent = (event, payload) => {
+            if (!response.writableEnded && !response.destroyed)
+                response.write(`event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`);
+        };
+        const heartbeat = setInterval(() => {
+            if (!response.writableEnded && !response.destroyed)
+                response.write(": heartbeat\n\n");
+        }, aiStreamHeartbeatIntervalMs);
+        heartbeat.unref();
+        response.on("close", () => {
+            clearInterval(heartbeat);
+            if (!response.writableEnded)
+                controller.abort(new Error("浏览器已中断流式请求"));
+        });
+        try {
+            const resumed = await resumeQuestionWorkflow(questionId, workId, viewer, {
+                signal: controller.signal,
+                onStart: (message) => sendEvent("continuation", message),
+                onDelta: (delta) => sendEvent("delta", { delta }),
+                onToolCall: (toolCall, round) => sendEvent("tool_call", { ...toolCall, round }),
+                onProcessStep: (step) => sendEvent("process_step", step),
+                onContextCompacted: (event) => sendEvent("context_compacted", event)
+            });
+            const message = resumed?.conversationMessage;
+            const metadata = message?.metadata;
+            sendEvent("complete", {
+                warningOnly: !resumed,
+                model: resumed?.model,
+                outputTokens: metadata?.outputTokens ?? resumed?.outputTokens,
+                cacheHitPercent: metadata?.cacheHitPercent ?? resumed?.cacheHitPercent,
+                processDurationMs: metadata?.processDurationMs ?? resumed?.processDurationMs,
+                toolCalls: metadata?.toolCalls ?? resumed?.toolCalls,
+                processSteps: metadata?.processSteps ?? resumed?.processSteps,
+                contextUsage: resumed?.contextUsage,
+                messageId: message?.id,
+                messageCreatedAt: message?.createdAt,
+                question: aiWritePlanManager.getQuestion(questionId, workId, viewer)
+            });
+        }
+        catch (error) {
+            if (!controller.signal.aborted)
+                sendEvent("error", publicAiStreamError(error));
+        }
+        finally {
+            clearInterval(heartbeat);
+            if (!response.writableEnded && !response.destroyed)
+                response.end();
+        }
+    };
     app.post("/api/works/:workId/ai/questions/:questionId/answer", async (request, response) => {
         const input = parse(answerAiUserQuestionSchema, request.body ?? {});
         const viewer = planViewer();
         aiWritePlanManager.answerQuestion(request.params.questionId, request.params.workId, viewer, input);
-        await resumeQuestionWorkflow(request.params.questionId, request.params.workId, viewer);
-        data(response, aiWritePlanManager.getQuestion(request.params.questionId, request.params.workId, viewer));
+        await respondWithQuestionContinuation(request, response, viewer);
     });
     app.post("/api/works/:workId/ai/questions/:questionId/reject", async (request, response) => {
         const viewer = planViewer();
         aiWritePlanManager.rejectQuestion(request.params.questionId, request.params.workId, viewer);
-        await resumeQuestionWorkflow(request.params.questionId, request.params.workId, viewer);
-        data(response, aiWritePlanManager.getQuestion(request.params.questionId, request.params.workId, viewer));
+        await respondWithQuestionContinuation(request, response, viewer);
     });
     app.get("/api/works/:workId/providers", (request, response) => {
         store.getWork(request.params.workId);