自作RSSリーダーにオンデバイスLLMを組み込んで、要約・シグナル分離・チャット・翻訳を全部端末内でやらせた話

const BASE_SYSTEM = `You are an RSS article summarization assistant.
Follow these rules strictly:
- Base your answer only on the provided article
- Distinguish speculation from facts
- Write "unknown" when information is unclear
- Return JSON only — no Markdown code blocks, no extra text`

export function buildBriefSummaryMessages(articleCtx, outputLanguage = 'ja') {
  const langName = getLanguageName(outputLanguage)
  const userContent = `Summarize the following article in 3–5 bullet points in ${langName}.

${buildArticleBlock(articleCtx)}

Output format (JSON only, no code block):
{"summary":["point 1","point 2","point 3"],"caveats":["note 1"]}`

  return [
    { role: 'system', content: `${BASE_SYSTEM}\n- Output language: ${langName}` },
    { role: 'user', content: userContent },
  ]
}

export function buildSignalsMessages(articleCtx, outputLanguage = 'ja') {
  const userContent = `Analyze the following article and classify its content by signal type in ${langName}.

Signal types to detect:
- "fact": confirmed dates, numbers, releases, specifications, verified events
- "claim": author's or company's interpretations, opinions, or assertions
- "speculation": predictions, uncertain conclusions, unconfirmed outlooks
- "quote": direct quotes or statements attributed to a specific person or source
- "promotion": product pitches, sign-up prompts, calls-to-action, sponsor language
- "unclear": statements with weak evidence, missing sources, or ambiguous meaning

Rules:
- Extract up to 3 items per signal type that is present in the article
- Omit signal types that are not present
- Keep each item concise (1–2 sentences)
- Assign confidence: "high", "medium", "low"
- If the article is too short to classify, set "insufficient": true and return an empty signals array

${buildArticleBlock(articleCtx)}

Output format (JSON only, no code block):
{"signals":[{"type":"fact","text":"...","confidence":"high"}],"insufficient":false}`
  // ...
}

You are an article reading assistant. Answer questions strictly based on the article provided below.

Rules:
- Answer only using information from this article
- If the article does not contain enough information to answer, say so clearly
- Distinguish between what the article states as fact vs opinion or speculation
- Keep answers concise and focused
- Do not make up or infer information not present in the article

export function buildTranslationMessages(paragraphs, targetLanguage) {
  const langName = getLanguageName(targetLanguage)
  const systemContent = `You are a translation assistant. Translate text to ${langName}.
Rules:
- Translate each paragraph faithfully, preserving meaning and tone
- Return JSON only — no Markdown code blocks, no extra text`
  const userContent = `Translate each paragraph to ${langName}. Return a JSON array with the same number of elements in the same order.

Input:
${JSON.stringify(paragraphs)}

Output format (JSON array only, no code block):
["translated paragraph 1","translated paragraph 2",...]`
  return [
    { role: 'system', content: systemContent },
    { role: 'user', content: userContent },
  ]
}

function limitParagraphsForTranslation(paragraphs, maxChars = 2500) {
  const result = []
  let total = 0
  for (const p of paragraphs) {
    if (total + p.length > maxChars) break
    result.push(p)
    total += p.length
  }
  return result.length > 0 ? result : paragraphs.slice(0, 1)
}

export function extractJson(rawText) {
  if (!rawText) return ''
  // ```json ... ``` または ``` ... ``` ブロックを除去
  const fenced = rawText.match(/```(?:json)?\s*([\s\S]*?)```/)
  if (fenced) return fenced[1].trim()
  // 最初の { と最後の } を探して切り出す
  const start = rawText.indexOf('{')
  const end = rawText.lastIndexOf('}')
  if (start !== -1 && end !== -1 && end > start) {
    return rawText.slice(start, end + 1)
  }
  return rawText.trim()
}

export function parseSummaryOutput(rawText) {
  const jsonStr = extractJson(rawText)
  let parsed
  try {
    parsed = JSON.parse(jsonStr)
  } catch (e) {
    return { ok: false, error: `JSON parse error: ${e.message}`, raw: rawText }
  }
  if (!parsed || !Array.isArray(parsed.summary) || parsed.summary.length === 0) {
    return { ok: false, error: 'Missing or empty summary array', raw: rawText }
  }
  // 文字列フィルタリング
  const data = {
    summary: parsed.summary.filter((s) => typeof s === 'string' && s.trim()),
    caveats: Array.isArray(parsed.caveats)
      ? parsed.caveats.filter((c) => typeof c === 'string' && c.trim())
      : [],
  }
  return { ok: true, data }
}

export function buildRepairPromptMessages(originalMessages, brokenRaw) {
  return [
    ...originalMessages,
    { role: 'assistant', content: brokenRaw },
    {
      role: 'user',
      content: 'Your previous response was not valid JSON. Please output only {"summary":[...],"caveats":[...]} with no code block or explanation.',
    },
  ]
}

function handleGenerationComplete(rawResponse) {
  const parsed = parseSummaryOutput(rawResponse)
  if (parsed.ok) {
    saveSummaryCache(...)
    setSummaryResults((prev) => ({ ...prev, [perspective]: parsed.data }))
  } else if (!pendingRef.current.retrying) {
    // 1回だけ修復プロンプトでリトライ
    const repairMessages = buildRepairPromptMessages(pendingRef.current.messages, rawResponse)
    pendingRef.current = { ...pendingRef.current, retrying: true }
    llm.generate(repairMessages).catch(handleError)
  } else {
    setError('要約の生成に失敗しました。再試行してください。')
  }
}

feedown:ai:summary:<articleId>:<contentHash>:<modelId>:<perspective>:<outputLanguage>
feedown:ai:summary:<articleId>:<contentHash>:<modelId>:signals:<outputLanguage>
feedown:ai:translation:<articleId>:<readerHash>:<modelId>:<targetLanguage>

function buildSummaryCacheKey(articleId, contentHash, modelId, perspective, outputLanguage) {
  return `${articleId}:${contentHash}:${modelId}:${perspective}:${outputLanguage}`
}

function isRecordValid(record, contentHash) {
  if (!record) return false
  if (record.modelDefinitionVersion !== MODEL_DEFINITION_VERSION) return false
  if (record.contentHash !== contentHash) return false
  return true
}

export function AiProvider({ children }) {
  const [settings, setSettings] = useState(DEFAULT_AI_SETTINGS)
  const [initialized, setInitialized] = useState(false)

  useEffect(() => {
    getAiSettings().then((loaded) => {
      setSettings(loaded)
      setInitialized(true)
    })
  }, [])

  const selectedModel = useMemo(
    () => getModelById(settings.selectedModelId) ?? getModelById(FEEDOWN_DEFAULT_LLM_ID),
    [settings.selectedModelId],
  )

  // preventLoad: AI 無効 / 初期化未完了 / ユーザーが Download を押していない
  const llm = useLLM({
    model: selectedModel?.executorchModel,
    preventLoad: !initialized || !settings.enabled || !settings.downloadEnabled,
  })

  return (
    <AiContext.Provider value={{ llm, settings, selectedModel, ... }}>
      {children}
    </AiContext.Provider>
  )
}

const pendingRef = useRef(null)
// 例: { feature: 'summary', perspective: 'brief', articleCtx, messages, outputLanguage, retrying: false }

useEffect(() => {
  if (!llm.isGenerating && pendingRef.current) {
    handleGenerationComplete(llm.response)
  }
}, [llm.isGenerating])

llm.generate(messages).catch((err) => {
  console.error(err)
  setError('生成に失敗しました')
  setIsLoading(false)
  pendingRef.current = null
})