@astro-minimax/ai 0.8.2 → 0.9.0

package/dist/server/notify.js

@@ -0,0 +1,70 @@
+import { createNotifier } from "@astro-minimax/notify";
+let notifierInstance = null;
+function getNotifier(env) {
+  if (notifierInstance) return notifierInstance;
+  const hasConfig = env.NOTIFY_TELEGRAM_BOT_TOKEN || env.NOTIFY_WEBHOOK_URL || env.NOTIFY_RESEND_API_KEY;
+  if (!hasConfig) {
+    console.warn("[notify] No notification providers configured. Missing environment variables: NOTIFY_TELEGRAM_BOT_TOKEN, NOTIFY_WEBHOOK_URL, or NOTIFY_RESEND_API_KEY");
+    return null;
+  }
+  const providers = [];
+  if (env.NOTIFY_TELEGRAM_BOT_TOKEN && env.NOTIFY_TELEGRAM_CHAT_ID) providers.push("telegram");
+  if (env.NOTIFY_WEBHOOK_URL) providers.push("webhook");
+  if (env.NOTIFY_RESEND_API_KEY && env.NOTIFY_RESEND_FROM && env.NOTIFY_RESEND_TO) providers.push("email");
+  console.log(`[notify] Initializing notifier with providers: ${providers.join(", ") || "none"}`);
+  notifierInstance = createNotifier({
+    telegram: env.NOTIFY_TELEGRAM_BOT_TOKEN && env.NOTIFY_TELEGRAM_CHAT_ID ? {
+      botToken: env.NOTIFY_TELEGRAM_BOT_TOKEN,
+      chatId: env.NOTIFY_TELEGRAM_CHAT_ID
+    } : void 0,
+    webhook: env.NOTIFY_WEBHOOK_URL ? {
+      url: env.NOTIFY_WEBHOOK_URL
+    } : void 0,
+    email: env.NOTIFY_RESEND_API_KEY && env.NOTIFY_RESEND_FROM && env.NOTIFY_RESEND_TO ? {
+      provider: "resend",
+      apiKey: env.NOTIFY_RESEND_API_KEY,
+      from: env.NOTIFY_RESEND_FROM,
+      to: env.NOTIFY_RESEND_TO
+    } : void 0
+  });
+  return notifierInstance;
+}
+function getMessageText(message) {
+  if (Array.isArray(message.parts)) {
+    return message.parts.filter((p) => p.type === "text").map((p) => p.text).join("");
+  }
+  return "";
+}
+function notifyAiChat(options) {
+  const { env, sessionId, messages, aiResponse, referencedArticles, model, usage, timing } = options;
+  const notifier = getNotifier(env);
+  if (!notifier) {
+    console.warn("[notify] AI chat notification skipped: no notifier available. Check environment variables.");
+    return Promise.resolve(null);
+  }
+  const userMessages = messages.filter((m) => m.role === "user");
+  const lastUserMessage = userMessages[userMessages.length - 1];
+  if (!lastUserMessage) {
+    console.warn("[notify] AI chat notification skipped: no user message found in messages array");
+    return Promise.resolve(null);
+  }
+  const userMessage = getMessageText(lastUserMessage);
+  const roundNumber = userMessages.length;
+  return notifier.aiChat({
+    sessionId,
+    roundNumber,
+    userMessage,
+    aiResponse: aiResponse?.slice(0, 500),
+    referencedArticles,
+    model,
+    usage,
+    timing,
+    siteUrl: env.SITE_URL
+  }).catch((error) => {
+    console.error("[notify] AI chat notification failed:", error);
+    return null;
+  });
+}
+export {
+  notifyAiChat
+};

package/dist/server/stream-helpers.js

@@ -0,0 +1,202 @@
+import {
+  streamText,
+  convertToModelMessages
+} from "ai";
+import { t } from "../utils/i18n.js";
+import { createChatStatusData } from "./types.js";
+import { createResponsePlaybackGenerator } from "../cache/response-cache.js";
+function writeSearchStatus(writer, count, lang) {
+  writer.write({
+    type: "message-metadata",
+    messageMetadata: createChatStatusData({
+      stage: "search",
+      message: t("ai.status.found", lang, { count }),
+      progress: 40
+    })
+  });
+}
+function writeGeneratingStatus(writer, lang, progress = 60) {
+  writer.write({
+    type: "message-metadata",
+    messageMetadata: createChatStatusData({
+      stage: "answer",
+      message: t("ai.status.generating", lang),
+      progress
+    })
+  });
+}
+function writeDoneStatus(writer, lang) {
+  writer.write({
+    type: "message-metadata",
+    messageMetadata: createChatStatusData({
+      stage: "answer",
+      message: t("ai.status.generating", lang),
+      progress: 100,
+      done: true
+    })
+  });
+}
+function writeSourceArticles(writer, articles, max = 3) {
+  for (const article of articles.slice(0, max)) {
+    try {
+      writer.write({
+        type: "source-url",
+        sourceId: `source-${article.title}`,
+        url: article.url ?? "#",
+        title: article.title
+      });
+    } catch {
+    }
+  }
+}
+function writeTextChunk(writer, text, idPrefix = "text") {
+  const id = `${idPrefix}-${Date.now()}`;
+  writer.write({ type: "text-start", id });
+  writer.write({ type: "text-delta", id, delta: text });
+  writer.write({ type: "text-end", id });
+}
+function writeFinish(writer, reason = "stop") {
+  writer.write({ type: "finish", finishReason: reason });
+}
+async function streamLLMResponse(params) {
+  const {
+    writer,
+    adapter,
+    systemPrompt,
+    messages,
+    lang,
+    temperature = 0.3,
+    maxOutputTokens = 2500
+  } = params;
+  const start = Date.now();
+  try {
+    const provider = adapter.getProvider();
+    const result = streamText({
+      model: provider.chatModel(adapter.model),
+      system: systemPrompt,
+      messages: await convertToModelMessages(messages),
+      temperature,
+      maxOutputTokens,
+      onError: ({ error }) => {
+        console.error("[stream-helpers] streamText error:", error);
+      }
+    });
+    const streamErrors = [];
+    writer.merge(result.toUIMessageStream({ sendFinish: false }));
+    await result.consumeStream({
+      onError: (error) => {
+        streamErrors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+    const text = await result.text;
+    let reasoningText;
+    const reasoningPromise = result.reasoning;
+    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 {
+      }
+    }
+    let tokenUsage;
+    const usagePromise = result.usage;
+    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 {
+      }
+    }
+    const generationMs = Date.now() - start;
+    if (streamErrors.length > 0) {
+      adapter.recordFailure(streamErrors[0]);
+      writeTextChunk(writer, t("ai.error.generic", lang), "error");
+      writeFinish(writer, "error");
+      return { success: true, responseText: text, reasoningText, tokenUsage, generationMs };
+    }
+    if (text.length > 0) {
+      adapter.recordSuccess();
+      writeFinish(writer);
+      return { success: true, responseText: text, reasoningText, tokenUsage, generationMs };
+    }
+    writeTextChunk(writer, t("ai.error.noOutput", lang), "no-output");
+    writeFinish(writer);
+    return { success: true, responseText: "", reasoningText, tokenUsage, generationMs };
+  } catch (err) {
+    adapter.recordFailure(err instanceof Error ? err : new Error(String(err)));
+    console.error("[stream-helpers] Provider threw:", err.message);
+    return { success: false, responseText: "", generationMs: Date.now() - start };
+  }
+}
+async function streamMockFallback(writer, question, lang) {
+  const { getMockResponse } = await import("../providers/mock.js");
+  const mockText = getMockResponse(question, lang);
+  writer.write({
+    type: "message-metadata",
+    messageMetadata: createChatStatusData({
+      stage: "answer",
+      message: t("ai.status.fallback", lang),
+      progress: 80
+    })
+  });
+  writeTextChunk(writer, mockText, "fallback");
+  writeFinish(writer);
+  return mockText;
+}
+async function streamCachedResponse(writer, cachedResponse, config, lang) {
+  writeSearchStatus(writer, cachedResponse.articles.length + cachedResponse.projects.length, lang);
+  writeGeneratingStatus(writer, lang);
+  writeSourceArticles(writer, cachedResponse.articles);
+  writeGeneratingStatus(writer, lang, 70);
+  const playbackGenerator = createResponsePlaybackGenerator(cachedResponse, config);
+  let thinkingId;
+  const textId = `text-${Date.now()}`;
+  let textStarted = false;
+  for await (const chunk of playbackGenerator) {
+    if (chunk.type === "thinking") {
+      if (!thinkingId) {
+        thinkingId = `thinking-${Date.now()}`;
+        writer.write({ type: "reasoning-start", id: thinkingId });
+      }
+      writer.write({ type: "reasoning-delta", id: thinkingId, delta: chunk.text });
+    } else {
+      if (thinkingId) {
+        writer.write({ type: "reasoning-end", id: thinkingId });
+        thinkingId = void 0;
+      }
+      if (!textStarted) {
+        writer.write({ type: "text-start", id: textId });
+        textStarted = true;
+      }
+      writer.write({ type: "text-delta", id: textId, delta: chunk.text });
+    }
+  }
+  if (thinkingId) {
+    writer.write({ type: "reasoning-end", id: thinkingId });
+  }
+  if (textStarted) {
+    writer.write({ type: "text-end", id: textId });
+  }
+  writeDoneStatus(writer, lang);
+  writeFinish(writer);
+}
+export {
+  streamCachedResponse,
+  streamLLMResponse,
+  streamMockFallback,
+  writeDoneStatus,
+  writeFinish,
+  writeGeneratingStatus,
+  writeSearchStatus,
+  writeSourceArticles,
+  writeTextChunk
+};

package/dist/server/types.js

@@ -0,0 +1,16 @@
+function createChatStatusData(partial) {
+  return {
+    ...partial,
+    done: partial.done ?? partial.stage === "complete",
+    at: Date.now()
+  };
+}
+function isChatStatusData(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return typeof v.stage === "string" && typeof v.message === "string" && typeof v.progress === "number";
+}
+export {
+  createChatStatusData,
+  isChatStatusData
+};

package/dist/stream/mock-stream.js

@@ -0,0 +1,26 @@
+import { getMockResponse } from "../providers/mock.js";
+function streamMockResponse(options) {
+  const { question, lang = "zh", delayRange = [12, 35] } = options;
+  const text = getMockResponse(question, lang);
+  const [minDelay, maxDelay] = delayRange;
+  let index = 0;
+  return new ReadableStream({
+    async pull(controller) {
+      if (index >= text.length) {
+        controller.close();
+        return;
+      }
+      const chunkSize = Math.random() < 0.25 ? 2 : 1;
+      const chunk = text.slice(index, index + chunkSize);
+      index += chunkSize;
+      controller.enqueue(chunk);
+      await sleep(minDelay + Math.random() * (maxDelay - minDelay));
+    }
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export {
+  streamMockResponse
+};

package/dist/stream/response.js

@@ -0,0 +1,21 @@
+const STREAM_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  "Connection": "keep-alive",
+  "Access-Control-Allow-Origin": "*"
+};
+const JSON_HEADERS = {
+  "Content-Type": "application/json",
+  "Access-Control-Allow-Origin": "*"
+};
+function errorResponse(message, status = 500) {
+  return new Response(JSON.stringify({ error: message }), {
+    status,
+    headers: JSON_HEADERS
+  });
+}
+export {
+  JSON_HEADERS,
+  STREAM_HEADERS,
+  errorResponse
+};

package/dist/utils/i18n.js

@@ -0,0 +1,154 @@
+const translations = {
+  en: {
+    // Reasoning UI
+    "ai.reasoning.thinking": "Thinking...",
+    "ai.reasoning.viewReasoning": "View reasoning",
+    "ai.reasoning.waiting": "Waiting for thoughts...",
+    // Error messages
+    "ai.error.network": "Network connection failed. Please check your connection.",
+    "ai.error.aborted": "Request was cancelled.",
+    "ai.error.rateLimit": "Too many requests. Please try again later.",
+    "ai.error.unavailable": "AI service is temporarily unavailable.",
+    "ai.error.generic": "Something went wrong. Please try again later.",
+    "ai.error.format": "Invalid request format.",
+    // UI labels
+    "ai.placeholder": "Ask a question...",
+    "ai.clear": "Clear",
+    "ai.clearConversation": "Clear conversation",
+    "ai.close": "Close",
+    "ai.closeChat": "Close chat",
+    "ai.retry": "Retry",
+    "ai.status.searching": "Searching...",
+    "ai.status.generating": "Generating response...",
+    "ai.status.found": "Found {count} related items",
+    "ai.status.citation": "Answered from public records",
+    "ai.status.fallback": "AI service unavailable, using demo mode",
+    // Quick prompts
+    "ai.prompt.techStack": "What tech stack is used?",
+    "ai.prompt.recommend": "Recommend some articles?",
+    "ai.prompt.build": "How to build a similar blog?",
+    "ai.prompt.summarize": 'Summarize the key points of "{title}"',
+    "ai.prompt.explain": 'Explain "{point}"',
+    "ai.prompt.related": "What related content should I read next?",
+    // Welcome messages
+    "ai.welcome.reading": `I'm reading "{title}" with you.
+Ask me to summarize, explain a concept, or explore related topics.`,
+    "ai.welcome.canHelp": "Hi! I'm the blog AI assistant. Ask me anything and I'll help you find related articles.",
+    "ai.welcome.greeting": "Hi! I'm the blog AI assistant.",
+    "ai.welcome.demo": "I'm running in demo mode. I can recommend blog articles and external resources.",
+    "ai.welcome.demoHint": "For full AI features (RAG search), configure AI_BASE_URL and AI_API_KEY.",
+    "ai.welcome.demoPrompt": 'Try: "Recommend articles?" or "How to build this blog?"',
+    // Header
+    "ai.header.reading": "Reading:",
+    "ai.header.mode": "Demo",
+    // Assistant branding
+    "ai.assistantName": "Blog Avatar",
+    "ai.status.live": "Live",
+    // Additional error messages
+    "ai.error.emptyMessage": "Message cannot be empty.",
+    "ai.error.emptyContent": "Message content cannot be empty.",
+    "ai.error.inputTooLong": "Message too long, max {max} characters.",
+    "ai.error.timeout": "Response timeout, please retry or simplify your question.",
+    // Rate limit messages
+    "ai.error.rateLimit.burst": "Too many requests, please try again later.",
+    "ai.error.rateLimit.sustained": "Too many requests, please wait a minute.",
+    "ai.error.rateLimit.daily": "Daily limit reached, please come back tomorrow.",
+    "ai.error.noOutput": "Sorry, I could not generate a valid response. Please try rephrasing your question.",
+    "ai.prompt.section.responsibilities": "Your Responsibilities",
+    "ai.prompt.section.format": "Response Format",
+    "ai.prompt.section.principles": "Recommendation Principles",
+    "ai.prompt.section.constraints": "Constraints",
+    "ai.prompt.section.sourceLayers": "Source Priority Protocol (must follow)",
+    "ai.prompt.section.privacy": "Privacy Protection",
+    "ai.prompt.section.answerModes": "Answer Mode Guide (follow detected mode)",
+    "ai.prompt.section.preOutputChecks": "Pre-Output Checks (execute mentally, do not output steps)",
+    "ai.semiStatic.blogOverview": "Blog Overview",
+    "ai.semiStatic.totalPosts": "{count} posts total",
+    "ai.semiStatic.mainCategories": "Main categories: {categories}",
+    "ai.semiStatic.latestArticles": "Latest Posts"
+  },
+  zh: {
+    // Reasoning UI
+    "ai.reasoning.thinking": "\u601D\u8003\u4E2D...",
+    "ai.reasoning.viewReasoning": "\u67E5\u770B\u601D\u8003\u8FC7\u7A0B",
+    "ai.reasoning.waiting": "\u7B49\u5F85\u601D\u8003...",
+    // Error messages
+    "ai.error.network": "\u7F51\u7EDC\u8FDE\u63A5\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC",
+    "ai.error.aborted": "\u8BF7\u6C42\u5DF2\u53D6\u6D88",
+    "ai.error.rateLimit": "\u8BF7\u6C42\u592A\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+    "ai.error.unavailable": "AI \u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528",
+    "ai.error.generic": "\u51FA\u4E86\u70B9\u95EE\u9898\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+    "ai.error.format": "\u8BF7\u6C42\u683C\u5F0F\u9519\u8BEF",
+    // UI labels
+    "ai.placeholder": "\u8F93\u5165\u4F60\u7684\u95EE\u9898...",
+    "ai.clear": "\u6E05\u9664",
+    "ai.clearConversation": "\u6E05\u9664\u5BF9\u8BDD",
+    "ai.close": "\u5173\u95ED",
+    "ai.closeChat": "\u5173\u95ED\u804A\u5929",
+    "ai.retry": "\u91CD\u8BD5",
+    "ai.status.searching": "\u641C\u7D22\u4E2D...",
+    "ai.status.generating": "\u6B63\u5728\u751F\u6210\u56DE\u7B54...",
+    "ai.status.found": "\u627E\u5230 {count} \u7BC7\u76F8\u5173\u5185\u5BB9",
+    "ai.status.citation": "\u5DF2\u57FA\u4E8E\u516C\u5F00\u8BB0\u5F55\u76F4\u63A5\u7ED9\u51FA\u56DE\u7B54",
+    "ai.status.fallback": "AI \u670D\u52A1\u4E0D\u53EF\u7528\uFF0C\u4F7F\u7528\u6F14\u793A\u6A21\u5F0F\u56DE\u590D",
+    // Quick prompts
+    "ai.prompt.techStack": "\u8FD9\u4E2A\u535A\u5BA2\u7528\u4E86\u4EC0\u4E48\u6280\u672F\uFF1F",
+    "ai.prompt.recommend": "\u6709\u54EA\u4E9B\u6587\u7AE0\u63A8\u8350\uFF1F",
+    "ai.prompt.build": "\u600E\u4E48\u642D\u5EFA\u7C7B\u4F3C\u7684\u535A\u5BA2\uFF1F",
+    "ai.prompt.summarize": "\u603B\u7ED3\u4E00\u4E0B\u300A{title}\u300B\u7684\u6838\u5FC3\u89C2\u70B9",
+    "ai.prompt.explain": "\u89E3\u91CA\u4E00\u4E0B\u300C{point}\u300D",
+    "ai.prompt.related": "\u8FD9\u7BC7\u6587\u7AE0\u548C\u54EA\u4E9B\u5185\u5BB9\u76F8\u5173\uFF1F",
+    // Welcome messages
+    "ai.welcome.reading": "\u6211\u5728\u7ED3\u5408\u300A{title}\u300B\u966A\u4F60\u9605\u8BFB\u3002\n\u4F60\u53EF\u4EE5\u8BA9\u6211\u603B\u7ED3\u8FD9\u7BC7\u6587\u7AE0\u3001\u89E3\u91CA\u67D0\u4E2A\u89C2\u70B9\uFF0C\u6216\u8005\u987A\u7740\u8FD9\u7BC7\u6587\u7AE0\u7EE7\u7EED\u5EF6\u4F38\u5230\u76F8\u5173\u4E3B\u9898\u3002",
+    "ai.welcome.canHelp": "\u4F60\u597D\uFF01\u6211\u662F\u535A\u5BA2 AI \u52A9\u624B\uFF0C\u95EE\u6211\u4EFB\u4F55\u5173\u4E8E\u535A\u5BA2\u5185\u5BB9\u7684\u95EE\u9898\uFF0C\u6211\u53EF\u4EE5\u5E2E\u4F60\u627E\u5230\u76F8\u5173\u6587\u7AE0\u3002",
+    "ai.welcome.greeting": "\u4F60\u597D\uFF01\u6211\u662F\u535A\u5BA2 AI \u52A9\u624B\u3002",
+    "ai.welcome.demo": "\u6211\u76EE\u524D\u5728 Demo \u6A21\u5F0F\u4E0B\uFF0C\u53EF\u4EE5\u63A8\u8350\u535A\u5BA2\u6587\u7AE0\u548C\u5916\u90E8\u8D44\u6E90\u3002",
+    "ai.welcome.demoHint": "\u542F\u7528\u5B8C\u6574 AI \u529F\u80FD\uFF08RAG \u641C\u7D22\u589E\u5F3A\uFF09\u9700\u8981\u914D\u7F6E AI_BASE_URL \u548C AI_API_KEY \u73AF\u5883\u53D8\u91CF\u3002",
+    "ai.welcome.demoPrompt": "\u8BD5\u8BD5\uFF1A\u300C\u6709\u54EA\u4E9B\u6587\u7AE0\u63A8\u8350\uFF1F\u300D\u6216\u300C\u600E\u4E48\u642D\u5EFA\u7C7B\u4F3C\u7684\u535A\u5BA2\uFF1F\u300D",
+    // Header
+    "ai.header.reading": "\u6B63\u5728\u9605\u8BFB\uFF1A",
+    "ai.header.mode": "\u6F14\u793A",
+    // Assistant branding
+    "ai.assistantName": "\u535A\u5BA2\u5206\u8EAB",
+    "ai.status.live": "\u5728\u7EBF",
+    // Additional error messages
+    "ai.error.emptyMessage": "\u6D88\u606F\u4E0D\u80FD\u4E3A\u7A7A\u3002",
+    "ai.error.emptyContent": "\u6D88\u606F\u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A\u3002",
+    "ai.error.inputTooLong": "\u6D88\u606F\u8FC7\u957F\uFF0C\u6700\u591A {max} \u5B57\u3002",
+    "ai.error.timeout": "\u54CD\u5E94\u8D85\u65F6\uFF0C\u8BF7\u91CD\u8BD5\u6216\u7B80\u5316\u95EE\u9898\u3002",
+    // Rate limit messages
+    "ai.error.rateLimit.burst": "\u8BF7\u6C42\u592A\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002",
+    "ai.error.rateLimit.sustained": "\u8BF7\u6C42\u6B21\u6570\u8FC7\u591A\uFF0C\u8BF7\u4E00\u5206\u949F\u540E\u518D\u8BD5\u3002",
+    "ai.error.rateLimit.daily": "\u4ECA\u65E5\u5BF9\u8BDD\u6B21\u6570\u5DF2\u8FBE\u4E0A\u9650\uFF0C\u8BF7\u660E\u5929\u518D\u6765\u3002",
+    "ai.error.noOutput": "\u62B1\u6B49\uFF0C\u6211\u65E0\u6CD5\u751F\u6210\u6709\u6548\u7684\u56DE\u7B54\u3002\u8BF7\u5C1D\u8BD5\u6362\u4E00\u79CD\u65B9\u5F0F\u63D0\u95EE\u3002",
+    "ai.prompt.section.responsibilities": "\u4F60\u7684\u804C\u8D23",
+    "ai.prompt.section.format": "\u56DE\u7B54\u683C\u5F0F",
+    "ai.prompt.section.principles": "\u63A8\u8350\u539F\u5219",
+    "ai.prompt.section.constraints": "\u7EA6\u675F",
+    "ai.prompt.section.sourceLayers": "\u6765\u6E90\u5206\u5C42\u534F\u8BAE\uFF08\u5FC5\u987B\u9075\u5B88\uFF09",
+    "ai.prompt.section.privacy": "\u9690\u79C1\u4FDD\u62A4",
+    "ai.prompt.section.answerModes": "\u56DE\u7B54\u6A21\u5F0F\u6307\u5BFC\uFF08\u6309\u68C0\u6D4B\u5230\u7684\u6A21\u5F0F\u6267\u884C\uFF09",
+    "ai.prompt.section.preOutputChecks": "\u8F93\u51FA\u524D\u68C0\u67E5\uFF08\u5728\u5FC3\u91CC\u6267\u884C\uFF0C\u4E0D\u8F93\u51FA\u6B65\u9AA4\uFF09",
+    "ai.semiStatic.blogOverview": "\u535A\u5BA2\u6982\u51B5",
+    "ai.semiStatic.totalPosts": "\u5171\u6709 {count} \u7BC7\u6587\u7AE0",
+    "ai.semiStatic.mainCategories": "\u4E3B\u8981\u5206\u7C7B\uFF1A{categories}",
+    "ai.semiStatic.latestArticles": "\u6700\u65B0\u6587\u7AE0"
+  }
+};
+function t(key, lang = "zh", vars) {
+  const l = lang === "zh" ? "zh" : "en";
+  let text = translations[l]?.[key] ?? translations["en"][key] ?? key;
+  if (vars) {
+    for (const [k, v] of Object.entries(vars)) {
+      text = text.replace(new RegExp(`\\{${k}\\}`, "g"), String(v));
+    }
+  }
+  return text;
+}
+function getLang(lang) {
+  return lang === "zh" ? "zh" : "en";
+}
+export {
+  getLang,
+  t
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astro-minimax/ai",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "type": "module",
   "description": "Vendor-agnostic AI integration package with full RAG pipeline for astro-minimax blogs — supports OpenAI, Cloudflare AI, and custom providers.",
   "author": "Souloss",
@@ -89,9 +89,9 @@
   "sideEffects": false,
   "dependencies": {
     "@ai-sdk/openai-compatible": "^2.0.35",
-    "@astro-minimax/notify": "^0.7.5",
     "ai": "^6.0.116",
-    "workers-ai-provider": "^3.1.2"
+    "workers-ai-provider": "^3.1.2",
+    "@astro-minimax/notify": "0.7.5"
   },
   "optionalDependencies": {
     "undici": "^6.0.0"