@astro-minimax/ai 0.8.2 → 0.9.0

package/dist/server/chat-handler.js

@@ -0,0 +1,603 @@
+import {
+  createUIMessageStream,
+  createUIMessageStreamResponse,
+  streamText,
+  convertToModelMessages
+} from "ai";
+import { t, getLang } from "../utils/i18n.js";
+import {
+  getClientIP,
+  checkRateLimit,
+  rateLimitResponse,
+  searchArticles,
+  searchProjects,
+  getSessionCacheKey,
+  getCachedContext,
+  setCachedContext,
+  shouldReuseSearchContext,
+  buildLocalSearchQuery,
+  shouldRunKeywordExtraction,
+  extractSearchKeywords,
+  KEYWORD_EXTRACTION_TIMEOUT_MS,
+  shouldSkipAnalysis,
+  analyzeRetrievedEvidence,
+  buildEvidenceSection,
+  EVIDENCE_ANALYSIS_TIMEOUT_MS,
+  getCitationGuardPreflight,
+  buildSystemPrompt,
+  getAuthorContext,
+  getVoiceProfile,
+  mergeResults,
+  getProviderManager,
+  createCacheAdapter,
+  detectPublicQuestion,
+  getGlobalSearchCache,
+  shouldAppendCitations,
+  formatCitationBlock,
+  selectCitations,
+  setGlobalSearchCache,
+  getGlobalCacheTTL,
+  getResponseCache,
+  setResponseCache,
+  getResponseCacheConfig,
+  rankArticlesByIntent,
+  matchFactsToQuery,
+  buildFactSection
+} from "../index.js";
+import { createChatStatusData } from "./types.js";
+import { errors, corsPreflightResponse } from "./errors.js";
+import { notifyAiChat } from "./notify.js";
+import {
+  writeSearchStatus,
+  writeGeneratingStatus,
+  writeSourceArticles,
+  streamLLMResponse,
+  streamMockFallback,
+  streamCachedResponse
+} from "./stream-helpers.js";
+const MAX_HISTORY_MESSAGES = 20;
+const MAX_INPUT_LENGTH = 500;
+const REQUEST_TIMEOUT_MS = 45e3;
+function sendNotification(args) {
+  const { env, messages, responseText, relatedArticles, model, usage, timing, cacheKey, waitUntil } = args;
+  const sessionId = cacheKey || `dev-${Date.now().toString(36)}`;
+  const notifyArticles = relatedArticles.slice(0, 5).map((a) => ({
+    title: a.title,
+    url: a.url
+  }));
+  const notifyPromise = notifyAiChat({
+    env,
+    sessionId,
+    messages,
+    aiResponse: responseText,
+    referencedArticles: notifyArticles,
+    model,
+    usage,
+    timing
+  });
+  if (waitUntil) {
+    waitUntil(notifyPromise);
+  } else {
+    void notifyPromise;
+  }
+}
+function getMessageText(message) {
+  if (Array.isArray(message.parts)) {
+    return message.parts.filter((p) => p.type === "text").map((p) => p.text).join("");
+  }
+  return "";
+}
+function hasContent(message) {
+  const text = getMessageText(message);
+  if (text.trim()) return true;
+  if (Array.isArray(message.parts)) {
+    return message.parts.some((p) => p.type !== "text");
+  }
+  return false;
+}
+function filterValidMessages(messages) {
+  const filtered = [];
+  let lastRole = null;
+  for (const msg of messages) {
+    if (!hasContent(msg)) continue;
+    if (msg.role === lastRole) continue;
+    filtered.push(msg);
+    lastRole = msg.role;
+  }
+  if (filtered.length > 0 && filtered[filtered.length - 1].role !== "user") {
+    filtered.pop();
+  }
+  return filtered;
+}
+function buildArticleContextPrompt(context) {
+  if (context.scope !== "article" || !context.article) return "";
+  const a = context.article;
+  const parts = [
+    "\n[\u5F53\u524D\u9605\u8BFB\u6587\u7AE0]",
+    `\u7528\u6237\u6B63\u5728\u9605\u8BFB\uFF1A\u300A${a.title}\u300B`
+  ];
+  if (a.summary) parts.push(`\u6458\u8981\uFF1A${a.summary}`);
+  if (a.abstract) parts.push(`\u8BE6\u7EC6\u6982\u8981\uFF1A${a.abstract}`);
+  if (a.keyPoints?.length) parts.push(`\u6838\u5FC3\u8981\u70B9\uFF1A${a.keyPoints.join("\uFF1B")}`);
+  if (a.categories?.length) parts.push(`\u5206\u7C7B\uFF1A${a.categories.join("\u3001")}`);
+  parts.push(
+    "",
+    "\u4F60\u6B63\u5728\u966A\u7528\u6237\u9605\u8BFB\u8FD9\u7BC7\u6587\u7AE0\u3002\u4F18\u5148\u56F4\u7ED5\u8FD9\u7BC7\u6587\u7AE0\u7684\u5185\u5BB9\u56DE\u7B54\u95EE\u9898\u3002",
+    "\u5F53\u7528\u6237\u7684\u95EE\u9898\u4E0E\u5F53\u524D\u6587\u7AE0\u76F8\u5173\u65F6\uFF0C\u5F15\u7528\u6587\u7AE0\u4E2D\u7684\u5177\u4F53\u5185\u5BB9\u3002",
+    "\u5F53\u7528\u6237\u60F3\u8981\u5EF6\u4F38\u65F6\uFF0C\u63A8\u8350\u76F8\u5173\u7684\u535A\u5BA2\u6587\u7AE0\u3002"
+  );
+  return parts.join("\n");
+}
+async function handleChatRequest(options) {
+  const { env, request: req, waitUntil } = options;
+  if (req.method === "OPTIONS") return corsPreflightResponse();
+  if (req.method !== "POST") return errors.methodNotAllowed("zh");
+  const ip = getClientIP(req);
+  const rateCheck = checkRateLimit(ip, env);
+  if (!rateCheck.allowed) return rateLimitResponse(rateCheck, "zh");
+  let body;
+  try {
+    body = await req.json();
+  } catch {
+    return errors.invalidRequest(t("ai.error.format", "zh"));
+  }
+  const lang = getLang(body.lang ?? env.SITE_LANG);
+  const context = body.context ?? { scope: "global" };
+  const rawMessages = (body.messages ?? []).slice(-MAX_HISTORY_MESSAGES);
+  if (!rawMessages.length) return errors.emptyMessage(lang);
+  const messages = filterValidMessages(rawMessages);
+  if (!messages.length) return errors.emptyMessage(lang);
+  const latestMessage = messages[messages.length - 1];
+  const latestText = getMessageText(latestMessage);
+  if (!latestText) return errors.emptyContent(lang);
+  if (latestText.length > MAX_INPUT_LENGTH) return errors.inputTooLong(MAX_INPUT_LENGTH, lang);
+  const requestAbort = new AbortController();
+  const requestTimer = setTimeout(() => requestAbort.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    return await runPipeline({ env, messages, latestText, context, req, requestAbort, lang, waitUntil });
+  } catch (err) {
+    if (requestAbort.signal.aborted) return errors.timeout(lang);
+    console.error("[chat-handler] Unexpected error:", err);
+    return errors.internal(void 0, lang);
+  } finally {
+    clearTimeout(requestTimer);
+  }
+}
+async function runPipeline(args) {
+  const { env, messages, latestText, context, req, lang, waitUntil } = args;
+  const timing = { start: Date.now() };
+  const cache = createCacheAdapter(env);
+  const responseCacheConfig = getResponseCacheConfig(env);
+  const manager = getProviderManager(env, {
+    enableMockFallback: true,
+    unhealthyThreshold: 3,
+    healthRecoveryTTL: 6e4
+  });
+  const hasRealProvider = manager.hasProviders();
+  const adapter = hasRealProvider ? await manager.getAvailableAdapter() : null;
+  const articleSlug = context.scope === "article" && context.article?.slug ? context.article.slug : void 0;
+  const publicQuestion = detectPublicQuestion(latestText);
+  let globalCacheHit = false;
+  let globalCacheType;
+  if (publicQuestion && (!publicQuestion.needsContext || articleSlug)) {
+    const globalCacheContext = { articleSlug, lang };
+    if (responseCacheConfig.enabled) {
+      const cachedResponse = await getResponseCache(cache, publicQuestion.type, globalCacheContext);
+      if (cachedResponse) {
+        globalCacheHit = true;
+        globalCacheType = publicQuestion.type;
+        const notifyTiming = { total: Date.now() - timing.start };
+        sendNotification({ env, messages, responseText: cachedResponse.response, relatedArticles: cachedResponse.articles, timing: notifyTiming, waitUntil });
+        const stream2 = createUIMessageStream({
+          execute: async ({ writer }) => {
+            await streamCachedResponse(writer, cachedResponse, responseCacheConfig, lang);
+          }
+        });
+        return createUIMessageStreamResponse({ stream: stream2, headers: { "Access-Control-Allow-Origin": "*", "Cache-Control": "no-cache" } });
+      }
+    }
+    const cachedSearch = await getGlobalSearchCache(cache, publicQuestion.type, globalCacheContext);
+    if (cachedSearch) {
+      globalCacheHit = true;
+      globalCacheType = publicQuestion.type;
+      const stream2 = createUIMessageStream({
+        execute: async ({ writer }) => {
+          const w = writer;
+          writeSearchStatus(w, cachedSearch.articles.length + cachedSearch.projects.length, lang);
+          if (cachedSearch.articles.length + cachedSearch.projects.length > 0) {
+            writeGeneratingStatus(w, lang);
+          }
+          writeSourceArticles(w, cachedSearch.articles);
+          let responseText = "";
+          if (adapter) {
+            const articlePrompt2 = buildArticleContextPrompt(context);
+            const matchedFacts2 = matchFactsToQuery(cachedSearch.query, lang);
+            const factPromptSection2 = buildFactSection(matchedFacts2, lang);
+            const systemPrompt2 = buildSystemPrompt({
+              static: { authorName: env.SITE_AUTHOR || "\u535A\u4E3B", siteUrl: env.SITE_URL || "", lang },
+              semiStatic: { authorContext: getAuthorContext(), voiceProfile: getVoiceProfile() },
+              dynamic: { userQuery: cachedSearch.query, articles: cachedSearch.articles, projects: cachedSearch.projects, evidenceSection: articlePrompt2, factSection: factPromptSection2 }
+            });
+            const llmResult = await streamLLMResponse({ writer: w, adapter, systemPrompt: systemPrompt2, messages, lang });
+            responseText = llmResult.responseText;
+            if (responseCacheConfig.enabled && llmResult.success && llmResult.responseText.length > 0) {
+              const globalTTL = getGlobalCacheTTL(publicQuestion.type);
+              const responseCacheData = {
+                query: cachedSearch.query,
+                thinking: llmResult.reasoningText,
+                response: llmResult.responseText,
+                articles: cachedSearch.articles,
+                projects: cachedSearch.projects,
+                lang,
+                model: adapter.model,
+                updatedAt: Date.now()
+              };
+              await setResponseCache(cache, publicQuestion.type, responseCacheData, globalTTL, globalCacheContext);
+            }
+          } else {
+            responseText = await streamMockFallback(w, latestText, lang);
+          }
+        }
+      });
+      return createUIMessageStreamResponse({ stream: stream2, headers: { "Access-Control-Allow-Origin": "*", "Cache-Control": "no-cache" } });
+    }
+  }
+  const cacheKey = getSessionCacheKey(req);
+  const now = Date.now();
+  const cachedContext = cacheKey ? await getCachedContext(cacheKey, cache) : void 0;
+  const userTurnCount = messages.filter((m) => m.role === "user").length;
+  const reuseContext = shouldReuseSearchContext({ latestText, cachedContext, userTurnCount, now });
+  let searchQuery = buildLocalSearchQuery(latestText) || latestText;
+  let relatedArticles = reuseContext && cachedContext ? cachedContext.articles : [];
+  let relatedProjects = reuseContext && cachedContext ? cachedContext.projects : [];
+  if (reuseContext && cachedContext && cacheKey) {
+    searchQuery = cachedContext.query;
+    await setCachedContext(cacheKey, { ...cachedContext, updatedAt: now }, cache);
+  } else {
+    if (hasRealProvider && adapter) {
+      const runKW = shouldRunKeywordExtraction({
+        messageCount: messages.length,
+        localQuery: searchQuery,
+        latestText
+      });
+      if (runKW) {
+        const kwStart = Date.now();
+        const abortCtrl = new AbortController();
+        const timeoutId = setTimeout(() => abortCtrl.abort(), KEYWORD_EXTRACTION_TIMEOUT_MS);
+        try {
+          const provider = adapter.getProvider();
+          const kwResult = await extractSearchKeywords({
+            messages,
+            provider,
+            model: adapter.keywordModel,
+            abortSignal: abortCtrl.signal
+          });
+          timing.keywordExtraction = Date.now() - kwStart;
+          if (kwResult.query && !kwResult.usedFallback) {
+            searchQuery = kwResult.query;
+            if (kwResult.primaryQuery && kwResult.primaryQuery !== searchQuery) {
+              const searchStart = Date.now();
+              const primary = searchArticles(kwResult.primaryQuery, { enableDeepContent: false });
+              relatedArticles = mergeResults(
+                searchArticles(searchQuery, { enableDeepContent: true }),
+                primary
+              );
+              relatedProjects = searchProjects(searchQuery);
+              timing.search = Date.now() - searchStart;
+            }
+          }
+        } catch {
+          timing.keywordExtraction = Date.now() - kwStart;
+        } finally {
+          clearTimeout(timeoutId);
+        }
+      }
+    }
+    if (!relatedArticles.length) {
+      const searchStart = Date.now();
+      relatedArticles = searchArticles(searchQuery, { enableDeepContent: true });
+      relatedProjects = searchProjects(searchQuery);
+      timing.search = Date.now() - searchStart;
+    }
+    relatedArticles = rankArticlesByIntent(latestText, relatedArticles);
+    if (cacheKey) {
+      await setCachedContext(cacheKey, {
+        query: searchQuery,
+        articles: relatedArticles,
+        projects: relatedProjects,
+        updatedAt: now
+      }, cache);
+    }
+    if (publicQuestion && (!publicQuestion.needsContext || articleSlug)) {
+      const globalTTL = getGlobalCacheTTL(publicQuestion.type);
+      await setGlobalSearchCache(
+        cache,
+        publicQuestion.type,
+        {
+          query: searchQuery,
+          articles: relatedArticles,
+          projects: relatedProjects,
+          updatedAt: now
+        },
+        globalTTL,
+        { articleSlug, lang }
+      );
+    }
+  }
+  let evidenceSection = "";
+  if (hasRealProvider && adapter) {
+    const skipEvidence = shouldSkipAnalysis(latestText, relatedArticles.length, "moderate");
+    if (!skipEvidence) {
+      const evidenceStart = Date.now();
+      const abortCtrl = new AbortController();
+      const timeoutId = setTimeout(() => abortCtrl.abort(), EVIDENCE_ANALYSIS_TIMEOUT_MS);
+      try {
+        const provider = adapter.getProvider();
+        const evidenceResult = await analyzeRetrievedEvidence({
+          userQuery: latestText,
+          articles: relatedArticles,
+          projects: relatedProjects,
+          provider,
+          model: adapter.evidenceModel,
+          abortSignal: abortCtrl.signal
+        });
+        if (evidenceResult.analysis) {
+          evidenceSection = buildEvidenceSection(evidenceResult.analysis);
+        }
+        timing.evidenceAnalysis = Date.now() - evidenceStart;
+      } catch {
+        timing.evidenceAnalysis = Date.now() - evidenceStart;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+  const preflight = getCitationGuardPreflight({
+    userQuery: latestText,
+    articles: relatedArticles,
+    projects: relatedProjects,
+    lang
+  });
+  const matchedFacts = matchFactsToQuery(latestText, lang);
+  const factPromptSection = buildFactSection(matchedFacts, lang);
+  const articlePrompt = buildArticleContextPrompt(context);
+  const systemPrompt = buildSystemPrompt({
+    static: {
+      authorName: env.SITE_AUTHOR || "\u535A\u4E3B",
+      siteUrl: env.SITE_URL || "",
+      lang
+    },
+    semiStatic: {
+      authorContext: getAuthorContext(),
+      voiceProfile: getVoiceProfile()
+    },
+    dynamic: {
+      userQuery: searchQuery,
+      articles: relatedArticles,
+      projects: relatedProjects,
+      evidenceSection: articlePrompt ? `${evidenceSection}
+${articlePrompt}` : evidenceSection,
+      factSection: factPromptSection,
+      lang
+    }
+  });
+  const stream = createUIMessageStream({
+    execute: async ({ writer }) => {
+      const articleCount = relatedArticles.length + relatedProjects.length;
+      if (articleCount > 0) {
+        writer.write({
+          type: "message-metadata",
+          messageMetadata: createChatStatusData({
+            stage: "search",
+            message: t("ai.status.found", lang, { count: articleCount }),
+            progress: 40
+          })
+        });
+      }
+      for (const article of relatedArticles.slice(0, 3)) {
+        try {
+          writer.write({
+            type: "source-url",
+            sourceId: `source-${article.title}`,
+            url: article.url ?? "#",
+            title: article.title
+          });
+        } catch {
+        }
+      }
+      if (preflight) {
+        writer.write({
+          type: "message-metadata",
+          messageMetadata: createChatStatusData({
+            stage: "answer",
+            message: t("ai.status.citation", lang),
+            progress: 100,
+            done: true
+          })
+        });
+        const partId = `preflight-${Date.now()}`;
+        writer.write({ type: "text-start", id: partId });
+        writer.write({ type: "text-delta", id: partId, delta: preflight.text });
+        writer.write({ type: "text-end", id: partId });
+        writer.write({ type: "finish", finishReason: "stop" });
+        return;
+      }
+      writer.write({
+        type: "message-metadata",
+        messageMetadata: createChatStatusData({
+          stage: "answer",
+          message: t("ai.status.generating", lang),
+          progress: 60
+        })
+      });
+      let streamSuccess = false;
+      let responseText = "";
+      let reasoningText;
+      let tokenUsage;
+      const generationStart = Date.now();
+      if (adapter) {
+        try {
+          const provider = adapter.getProvider();
+          const result = streamText({
+            model: provider.chatModel(adapter.model),
+            system: systemPrompt,
+            messages: await convertToModelMessages(messages),
+            temperature: 0.3,
+            maxOutputTokens: 2500,
+            onError: ({ error }) => {
+              console.error("[chat-handler] streamText error:", error);
+            }
+          });
+          let hasTextOutput = false;
+          const errors2 = [];
+          writer.merge(result.toUIMessageStream({ sendFinish: false }));
+          await result.consumeStream({
+            onError: (error) => {
+              errors2.push(error instanceof Error ? error : new Error(String(error)));
+            }
+          });
+          const text = await result.text;
+          const reasoningPromise = result.reasoning;
+          const usagePromise = result.usage;
+          if (reasoningPromise) {
+            try {
+              const reasoningOutput = await Promise.resolve(reasoningPromise);
+              reasoningText = typeof reasoningOutput === "string" ? reasoningOutput : Array.isArray(reasoningOutput) ? reasoningOutput.map((r) => {
+                if (typeof r === "object" && r !== null && "text" in r) return r.text;
+                return String(r);
+              }).join("") : void 0;
+            } catch {
+            }
+          }
+          if (usagePromise) {
+            try {
+              const usage = await Promise.resolve(usagePromise);
+              const inputTokens = usage.inputTokens ?? 0;
+              const outputTokens = usage.outputTokens ?? 0;
+              tokenUsage = {
+                total: usage.totalTokens ?? inputTokens + outputTokens,
+                input: inputTokens,
+                output: outputTokens
+              };
+            } catch {
+            }
+          }
+          timing.generation = Date.now() - generationStart;
+          responseText = text;
+          hasTextOutput = text.length > 0;
+          if (hasTextOutput && errors2.length === 0) {
+            adapter.recordSuccess();
+            if (shouldAppendCitations(responseText, relatedArticles, relatedProjects)) {
+              const citations = selectCitations(relatedArticles, relatedProjects, 3, 5);
+              if (citations.length > 0) {
+                const citationBlock = formatCitationBlock(citations, lang);
+                const citationId = `citation-${Date.now()}`;
+                writer.write({ type: "text-start", id: citationId });
+                writer.write({ type: "text-delta", id: citationId, delta: citationBlock });
+                writer.write({ type: "text-end", id: citationId });
+                responseText += citationBlock;
+              }
+            }
+            writer.write({ type: "finish", finishReason: "stop" });
+            streamSuccess = true;
+            if (responseCacheConfig.enabled && publicQuestion && (!publicQuestion.needsContext || articleSlug)) {
+              const globalTTL = getGlobalCacheTTL(publicQuestion.type);
+              const responseCacheData = {
+                query: searchQuery,
+                thinking: reasoningText,
+                response: text,
+                articles: relatedArticles,
+                projects: relatedProjects,
+                lang,
+                model: adapter.model,
+                updatedAt: Date.now()
+              };
+              await setResponseCache(cache, publicQuestion.type, responseCacheData, globalTTL, { articleSlug, lang });
+            }
+          } else if (errors2.length > 0) {
+            adapter.recordFailure(errors2[0]);
+            console.error("[chat-handler] Stream error:", errors2[0].message);
+            const errorId = `error-${Date.now()}`;
+            writer.write({ type: "text-start", id: errorId });
+            writer.write({
+              type: "text-delta",
+              id: errorId,
+              delta: t("ai.error.generic", lang)
+            });
+            writer.write({ type: "text-end", id: errorId });
+            writer.write({ type: "finish", finishReason: "error" });
+            streamSuccess = true;
+          } else if (!hasTextOutput) {
+            const noOutputId = `no-output-${Date.now()}`;
+            writer.write({ type: "text-start", id: noOutputId });
+            writer.write({ type: "text-delta", id: noOutputId, delta: t("ai.error.noOutput", lang) });
+            writer.write({ type: "text-end", id: noOutputId });
+            writer.write({ type: "finish", finishReason: "stop" });
+            streamSuccess = true;
+          } else {
+            writer.write({ type: "finish", finishReason: "stop" });
+            streamSuccess = true;
+          }
+        } catch (err) {
+          timing.generation = Date.now() - generationStart;
+          adapter.recordFailure(err instanceof Error ? err : new Error(String(err)));
+          console.error("[chat-handler] Provider threw:", err.message);
+        }
+      }
+      if (!streamSuccess) {
+        const { getMockResponse } = await import("../providers/mock.js");
+        const mockText = getMockResponse(latestText, lang);
+        timing.generation = Date.now() - generationStart;
+        responseText = mockText;
+        writer.write({
+          type: "message-metadata",
+          messageMetadata: createChatStatusData({
+            stage: "answer",
+            message: t("ai.status.fallback", lang),
+            progress: 80
+          })
+        });
+        const fallbackId = `fallback-${Date.now()}`;
+        writer.write({ type: "text-start", id: fallbackId });
+        writer.write({ type: "text-delta", id: fallbackId, delta: mockText });
+        writer.write({ type: "text-end", id: fallbackId });
+        writer.write({ type: "finish", finishReason: "stop" });
+      }
+      if (responseText) {
+        const notifyTiming = {
+          total: Date.now() - timing.start,
+          keywordExtraction: timing.keywordExtraction,
+          search: timing.search,
+          evidenceAnalysis: timing.evidenceAnalysis,
+          generation: timing.generation
+        };
+        const notifyModel = adapter ? {
+          name: adapter.model,
+          provider: env.AI_PROVIDER || void 0,
+          apiHost: env.AI_BASE_URL || void 0
+        } : void 0;
+        sendNotification({
+          env,
+          messages,
+          responseText,
+          relatedArticles,
+          model: notifyModel,
+          usage: tokenUsage,
+          timing: notifyTiming,
+          cacheKey,
+          waitUntil
+        });
+      }
+    }
+  });
+  return createUIMessageStreamResponse({
+    stream,
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Cache-Control": "no-cache"
+    }
+  });
+}
+export {
+  handleChatRequest
+};

package/dist/server/errors.js

@@ -0,0 +1,46 @@
+import { t } from "../utils/i18n.js";
+const CORS_HEADERS = {
+  "Content-Type": "application/json",
+  "Access-Control-Allow-Origin": "*"
+};
+function chatError(code, error, status, options) {
+  const body = {
+    error,
+    code,
+    retryable: options?.retryable ?? false,
+    retryAfter: options?.retryAfter
+  };
+  const headers = { ...CORS_HEADERS };
+  if (options?.retryAfter) {
+    headers["Retry-After"] = String(options.retryAfter);
+  }
+  return new Response(JSON.stringify(body), { status, headers });
+}
+function te(key, lang, vars) {
+  return t(key, lang ?? "zh", vars);
+}
+const errors = {
+  methodNotAllowed: (lang) => chatError("METHOD_NOT_ALLOWED", lang === "en" ? "Method not allowed" : "\u65B9\u6CD5\u4E0D\u5141\u8BB8", 405),
+  invalidRequest: (detail, lang) => chatError("INVALID_REQUEST", detail ?? te("ai.error.format", lang), 400),
+  emptyMessage: (lang) => chatError("INVALID_REQUEST", te("ai.error.emptyMessage", lang), 400),
+  emptyContent: (lang) => chatError("INVALID_REQUEST", te("ai.error.emptyContent", lang), 400),
+  inputTooLong: (max, lang) => chatError("INPUT_TOO_LONG", te("ai.error.inputTooLong", lang, { max }), 400),
+  rateLimited: (retryAfter, lang) => chatError("RATE_LIMITED", te("ai.error.rateLimit", lang), 429, { retryable: true, retryAfter: retryAfter ?? 10 }),
+  timeout: (lang) => chatError("TIMEOUT", te("ai.error.timeout", lang), 504, { retryable: true }),
+  providerUnavailable: (lang) => chatError("PROVIDER_UNAVAILABLE", te("ai.error.unavailable", lang), 503, { retryable: true, retryAfter: 30 }),
+  internal: (detail, lang) => chatError("INTERNAL_ERROR", detail ?? te("ai.error.generic", lang), 500, { retryable: true, retryAfter: 5 })
+};
+function corsPreflightResponse() {
+  return new Response(null, {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "POST, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, x-session-id"
+    }
+  });
+}
+export {
+  chatError,
+  corsPreflightResponse,
+  errors
+};

package/dist/server/metadata-init.js

@@ -0,0 +1,49 @@
+import {
+  preloadMetadata,
+  getAuthorContext,
+  getAllSummaries,
+  initArticleIndex,
+  initProjectIndex
+} from "../index.js";
+let initialized = false;
+function initializeMetadata(config, env) {
+  if (initialized) return;
+  initialized = true;
+  preloadMetadata({
+    summaries: config.summaries,
+    authorContext: config.authorContext,
+    voiceProfile: config.voiceProfile,
+    factRegistry: config.factRegistry ?? null,
+    vectorIndex: config.vectorIndex ?? null
+  });
+  const authorCtx = getAuthorContext();
+  const allSummaries = getAllSummaries();
+  const summaryMap = new Map(allSummaries.map((s) => [s.slug, s]));
+  const siteUrl = config.siteUrl ?? env?.SITE_URL ?? "";
+  const articleDocs = (authorCtx?.posts ?? []).map((post) => {
+    const summary = summaryMap.get(post.id);
+    const baseUrl = post.url?.startsWith("http") ? "" : siteUrl;
+    return {
+      id: post.id,
+      title: post.title,
+      url: post.url ? `${baseUrl}${post.url}` : `${siteUrl}/${post.id}`,
+      excerpt: post.summary || summary?.summary || "",
+      content: [...post.keyPoints ?? [], ...summary?.keyPoints ?? []].join(" "),
+      categories: [post.category].filter(Boolean),
+      tags: post.tags ?? [],
+      keyPoints: [...post.keyPoints ?? [], ...summary?.keyPoints ?? []],
+      dateTime: post.date ? new Date(post.date).getTime() : 0,
+      lang: post.lang,
+      summary: summary?.summary
+    };
+  });
+  initArticleIndex(articleDocs);
+  initProjectIndex([]);
+}
+function resetMetadataInit() {
+  initialized = false;
+}
+export {
+  initializeMetadata,
+  resetMetadataInit
+};