@musnows/scriverse 0.7.2 → 0.7.4

package/dist/public/ai-connectivity-test.js

@@ -0,0 +1,82 @@
+const objectLabels = Object.freeze({ provider: "供应商", model: "模型" });
+
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+function objectLabel(objectType) {
+  return objectLabels[objectType] ?? "AI 配置";
+}
+
+function retryTimeText(retryAt) {
+  if (typeof retryAt !== "string" || !retryAt) return "";
+  const date = new Date(retryAt);
+  if (!Number.isFinite(date.getTime())) return "";
+  return `，可于 ${date.toLocaleTimeString("zh-CN", { hour: "2-digit", minute: "2-digit", second: "2-digit", hour12: false })} 再次测试`;
+}
+
+function remainingSeconds(value, fallback) {
+  const seconds = Number(value);
+  return Number.isFinite(seconds) && seconds > 0 ? Math.ceil(seconds) : fallback;
+}
+
+export function connectivityTestResultToast(result, objectType) {
+  const source = record(result);
+  const cooldown = record(source.cooldown);
+  const label = objectLabel(objectType);
+  if (cooldown.reason === "configuration_changed") {
+    const outcome = source.ok === false && typeof source.error === "string"
+      ? `旧配置测试失败：${source.error}；`
+      : "旧配置测试已完成；";
+    return {
+      message: `${label}${outcome}配置已在测试期间更新，旧结果不会锁定新配置，现在可以重新测试`,
+      type: "warning"
+    };
+  }
+  if (source.ok === true) {
+    const imageNotice = objectType === "model" && source.multimodalTested === true ? "，图片请求已验证" : "";
+    return {
+      message: `${label}连接测试成功${imageNotice}；接下来 2 分钟内不能再次测试${retryTimeText(cooldown.retryAt)}`,
+      type: "info"
+    };
+  }
+  const failure = typeof source.error === "string" && source.error ? source.error : "未知错误";
+  return {
+    message: `${label}连接测试失败：${failure}；10 秒后可以重试${retryTimeText(cooldown.retryAt)}`,
+    type: "error"
+  };
+}
+
+export function connectivityTestErrorToast(error, objectType) {
+  const source = record(error);
+  const details = record(source.details);
+  const label = objectLabel(objectType);
+  if (details.reason === "in_progress") {
+    const seconds = remainingSeconds(details.retryAfterSeconds, 1);
+    return {
+      message: `${label}已有连接测试正在进行，请等待约 ${seconds} 秒${retryTimeText(details.retryAt)}`,
+      type: "warning"
+    };
+  }
+  if (details.reason === "success_cooldown") {
+    const seconds = remainingSeconds(details.retryAfterSeconds, 120);
+    return {
+      message: `${label}仍在成功冷却中，剩余 ${seconds} 秒${retryTimeText(details.retryAt)}`,
+      type: "warning"
+    };
+  }
+  if (details.reason === "failure_cooldown") {
+    const seconds = remainingSeconds(details.retryAfterSeconds, 10);
+    return {
+      message: `${label}仍在失败冷却中，剩余 ${seconds} 秒${retryTimeText(details.retryAt)}`,
+      type: "warning"
+    };
+  }
+  const message = typeof source.message === "string" && source.message ? source.message : "请求失败";
+  return { message: `${label}连接测试失败：${message}`, type: "error" };
+}
+
+export function connectivityConfigurationSavedToast(objectType) {
+  const label = objectLabel(objectType);
+  return `${label}配置已保存，旧连接测试冷却已清除，现在可以重新测试`;
+}

package/dist/public/ai-context-meter.js

@@ -17,6 +17,33 @@ export function resolveAiContextUsage(previousUsage, nextUsage) {
   return nextUsage && typeof nextUsage === "object" ? nextUsage : previousUsage ?? null;
 }
 
+const maximumAiContextUsageFields = [
+  "inputTokens",
+  "contextTokens",
+  "conversationTokens",
+  "usagePercent",
+  "conversationUsagePercent"
+];
+const minimumAiContextUsageFields = ["remainingTokens"];
+
+export function mergeAiContextUsage(previousUsage, nextUsage, allowShrink = false) {
+  if (!nextUsage || typeof nextUsage !== "object" || Array.isArray(nextUsage)) return previousUsage ?? null;
+  if (!previousUsage || typeof previousUsage !== "object" || Array.isArray(previousUsage) || allowShrink) return nextUsage;
+  const mergedUsage = { ...nextUsage };
+  for (const field of [...maximumAiContextUsageFields, ...minimumAiContextUsageFields]) {
+    const previousValue = Number(previousUsage[field]);
+    const nextValue = Number(nextUsage[field]);
+    if (Number.isFinite(previousValue) && Number.isFinite(nextValue)) {
+      mergedUsage[field] = minimumAiContextUsageFields.includes(field)
+        ? Math.min(previousValue, nextValue)
+        : Math.max(previousValue, nextValue);
+    }
+    else if (Number.isFinite(previousValue)) mergedUsage[field] = previousValue;
+    else if (Number.isFinite(nextValue)) mergedUsage[field] = nextValue;
+  }
+  return mergedUsage;
+}
+
 export function formatAiContextUsagePercent(occupiedTokens, contextWindow) {
   const occupied = tokenCount(occupiedTokens);
   const window = tokenCount(contextWindow);

package/dist/public/ai-mentions.js

@@ -67,3 +67,17 @@ export function mergeAiReferenceScope(scope, references) {
   if (referenceScope.includeSettingInfo === true) merged.includeSettingInfo = true;
   return merged;
 }
+
+export function userMessageMentionNames(mentionCharacterIds, characters) {
+  if (!Array.isArray(mentionCharacterIds) || !Array.isArray(characters)) return [];
+  const characterNames = new Map(characters.map((item) => [String(item?.id ?? ""), String(item?.name ?? "").trim()]));
+  const seen = new Set();
+  const names = [];
+  for (const characterId of mentionCharacterIds) {
+    if (typeof characterId !== "string" || seen.has(characterId)) continue;
+    seen.add(characterId);
+    const name = characterNames.get(characterId);
+    if (name) names.push(name);
+  }
+  return names;
+}

package/dist/public/ai-request-manager.js

@@ -0,0 +1,99 @@
+function normalizedId(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || null;
+}
+
+export function createAiRequestAbortError(message = "AI 请求已取消") {
+  const error = new Error(message);
+  error.name = "AbortError";
+  error.code = "AI_REQUEST_CANCELLED";
+  return error;
+}
+
+export function isAiRequestCancellation(error, request = null) {
+  if (request?.signal?.aborted) return true;
+  return error?.name === "AbortError" || error?.code === "AI_REQUEST_CANCELLED";
+}
+
+export function aiRequestTargetsState(request, current) {
+  if (!request || normalizedId(current?.workId) !== request.workId) return false;
+  return request.conversationId === null
+    || normalizedId(current?.conversationId) === request.conversationId;
+}
+
+export function createAiRequestManager() {
+  let generation = 0;
+  let active = null;
+
+  const snapshot = (input, controller, requestGeneration) => Object.freeze({
+    generation: requestGeneration,
+    workId: normalizedId(input.workId),
+    conversationId: normalizedId(input.conversationId),
+    userMessageId: normalizedId(input.userMessageId),
+    signal: controller.signal
+  });
+
+  const isCurrent = (request) => Boolean(
+    request
+    && active
+    && !active.controller.signal.aborted
+    && active.snapshot.generation === request.generation
+    && active.controller.signal === request.signal
+  );
+
+  const cancel = (reason = "AI 请求已取消") => {
+    if (!active) return false;
+    const current = active;
+    active = null;
+    current.controller.abort(createAiRequestAbortError(reason));
+    return true;
+  };
+
+  const begin = (input) => {
+    cancel("新的 AI 请求已开始");
+    const controller = new AbortController();
+    generation += 1;
+    const request = snapshot(input, controller, generation);
+    if (!request.workId) throw new Error("AI 请求必须绑定作品");
+    active = { controller, snapshot: request };
+    return request;
+  };
+
+  const bind = (request, patch) => {
+    if (!isCurrent(request)) throw createAiRequestAbortError("AI 请求已失效");
+    const conversationId = Object.hasOwn(patch, "conversationId")
+      ? normalizedId(patch.conversationId)
+      : request.conversationId;
+    const userMessageId = Object.hasOwn(patch, "userMessageId")
+      ? normalizedId(patch.userMessageId)
+      : request.userMessageId;
+    if (request.conversationId && conversationId !== request.conversationId) {
+      throw new Error("AI 请求不能改绑到其他对话");
+    }
+    if (request.userMessageId && userMessageId !== request.userMessageId) {
+      throw new Error("AI 请求不能改绑到其他用户消息");
+    }
+    const next = snapshot({
+      workId: request.workId,
+      conversationId,
+      userMessageId
+    }, active.controller, request.generation);
+    active.snapshot = next;
+    return next;
+  };
+
+  const finish = (request) => {
+    if (!isCurrent(request)) return false;
+    active = null;
+    return true;
+  };
+
+  return {
+    begin,
+    bind,
+    cancel,
+    finish,
+    hasActive: () => active !== null,
+    isCurrent
+  };
+}

package/dist/public/ai-stream-protocol.js

@@ -0,0 +1,51 @@
+function streamTransportError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  error.status = 502;
+  return error;
+}
+
+export function assertAiStreamCompleted(completed) {
+  if (completed) return;
+  throw streamTransportError(
+    "AI_STREAM_UPSTREAM_CLOSED",
+    "AI 流在收到完成事件前已关闭，已保留已生成内容"
+  );
+}
+
+export async function readAiEventStream(body, onEvent) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let completed = false;
+  const consume = async (eventText) => {
+    let eventName = "message";
+    const dataLines = [];
+    for (const line of eventText.split(/\r?\n/)) {
+      if (line.startsWith("event:")) eventName = line.slice(6).trim();
+      if (line.startsWith("data:")) dataLines.push(line.slice(5).trimStart());
+    }
+    if (!dataLines.length) return;
+    const payload = JSON.parse(dataLines.join("\n"));
+    await onEvent(eventName, payload);
+    if (eventName === "complete") completed = true;
+  };
+  while (true) {
+    let chunk;
+    try {
+      chunk = await reader.read();
+    } catch {
+      throw streamTransportError(
+        "AI_STREAM_NETWORK_ERROR",
+        "AI 流连接中断，已保留已生成内容"
+      );
+    }
+    buffer += decoder.decode(chunk.value, { stream: !chunk.done });
+    const events = buffer.split(/\r?\n\r?\n/);
+    buffer = events.pop() ?? "";
+    for (const eventText of events) await consume(eventText);
+    if (chunk.done) break;
+  }
+  if (buffer.trim()) await consume(buffer);
+  return { completed };
+}