多轮对话接口

// POST /api/chat
{
  prompt: "什么是 TypeScript？"
}

// messages.ts
const messages = [
  { role: 'system',    content: '你是一个前端开发导师，用简洁的语言回答问题。' },
  { role: 'user',      content: '什么是 TypeScript？' },
  { role: 'assistant', content: 'TypeScript 是 JavaScript 的超集，主要特点是加了静态类型系统。' },
  { role: 'user',      content: '它有什么优缺点？' },
  { role: 'assistant', content: '优点：编译期发现错误、IDE 补全更好、重构更安全。缺点：学习成本、编译步骤、小项目收益不明显。' },
  { role: 'user',      content: '能展开说说编译期发现错误吗？' },
]

// session-id.ts
import { randomUUID } from 'crypto'
 
// 用户点击「新建对话」时，前端调这个接口
app.post('/api/conversations', (c) => {
  const sessionId = randomUUID()
 
  // sessionId 返回给前端，后续所有请求都带上它
  return c.json({ sessionId })
})

// client.ts
const response = await fetch('/api/chat', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    sessionId: 'a1b2c3d4-...',
    message: '能展开说说编译期发现错误吗？',
  }),
})

// conversation-store.ts
import type { Message } from './types'
 
const KEY_PREFIX = 'conversation:'
 
// 读取历史消息
async function getHistory(
  kv: KVNamespace,
  sessionId: string
): Promise<Message[]> {
  const key = `${KEY_PREFIX}${sessionId}`
  const raw = await kv.get(key, 'json')
  return (raw as Message[]) ?? []
}
 
// 追加新消息（读 → 追加 → 写回）
async function appendMessage(
  kv: KVNamespace,
  sessionId: string,
  message: Message
): Promise<void> {
  const history = await getHistory(kv, sessionId)
  history.push(message)
  const key = `${KEY_PREFIX}${sessionId}`
  // KV 的 value 最大 25 MB，对话历史远不会到
  await kv.put(key, JSON.stringify(history))
}

// 7 天没新消息就自动过期
await kv.put(key, JSON.stringify(history), { expirationTtl: 60 * 60 * 24 * 7 })

// token-estimate.ts
// 粗略估算 token 数，精确计算请换用对应模型的 tokenizer
function estimateTokens(text: string): number {
  let count = 0
  for (const char of text) {
    if (char.charCodeAt(0) > 127) {
      count += 1.5 // 非 ASCII（中文、日文等）
    } else {
      count += 0.25 // ASCII 字符
    }
  }
  return Math.ceil(count)
}

// truncate.ts
import type { Message } from './types'
 
function keepLastN(messages: Message[], n: number): Message[] {
  // system prompt 永远保留，不参与截断计数
  const system = messages.filter((m) => m.role === 'system')
  const nonSystem = messages.filter((m) => m.role !== 'system')
 
  const kept = nonSystem.slice(-n)
 
  return [...system, ...kept]
}

// truncate.ts
function truncateByTokenBudget(
  messages: Message[],
  budgetTokens: number,
  estimateTokens: (msgs: Message[]) => number
): Message[] {
  const system = messages.filter((m) => m.role === 'system')
  const nonSystem = messages.filter((m) => m.role !== 'system')
 
  // 从最新的消息往回取，直到超出预算
  const kept: Message[] = []
  for (let i = nonSystem.length - 1; i >= 0; i--) {
    const candidate = [nonSystem[i], ...kept]
    if (estimateTokens([...system, ...candidate]) > budgetTokens) {
      break
    }
    kept.unshift(nonSystem[i])
  }
 
  return [...system, ...kept]
}

// truncate.ts
async function summarizeAndTruncate(
  messages: Message[],
  budgetTokens: number,
  ai: Ai
): Promise<Message[]> {
  const system = messages.filter((m) => m.role === 'system')
  const nonSystem = messages.filter((m) => m.role !== 'system')
  const splitPoint = Math.floor(nonSystem.length / 2)
  const toSummarize = nonSystem.slice(0, splitPoint)
  const toKeep = nonSystem.slice(splitPoint)
 
  const result = await ai.run('@cf/meta/llama-3.1-8b-instruct', {
    messages: [
      { role: 'system', content: '用 3-5 句话总结以下对话的关键信息。' },
      { role: 'user', content: toSummarize.map((m) => `${m.role}: ${m.content}`).join('\n') },
    ],
  })
 
  const summaryMsg: Message = {
    role: 'system',
    content: `之前对话的摘要：${(result as { response: string }).response}`,
  }
 
  return [...system, summaryMsg, ...toKeep]
}

// src/routes/chat.ts
import { Hono } from 'hono'
import type { Message } from '../types'
import { getHistory, appendMessage } from '../lib/conversation-store'
import { truncateByTokenBudget, estimateMessagesTokens } from '../lib/truncate'
 
type Bindings = {
  KV: KVNamespace
  AI: Ai
  OPENAI_API_KEY: string
}
 
const app = new Hono<{ Bindings: Bindings }>()
 
// 模型输入 Token 预算，留出空间给输出
const INPUT_TOKEN_BUDGET = 60_000
 
app.post('/api/chat', async (c) => {
  const { sessionId, message, systemPrompt } = await c.req.json<{
    sessionId: string
    message: string
    systemPrompt?: string
  }>()
 
  if (!sessionId || !message) {
    return c.json({ error: 'sessionId and message are required' }, 400)
  }
 
  // 1. 读取历史消息
  const history = await getHistory(c.env.KV, sessionId)
 
  // 2. 如果是新会话的第一条消息，插入 system prompt
  if (history.length === 0 && systemPrompt) {
    await appendMessage(c.env.KV, sessionId, {
      role: 'system',
      content: systemPrompt,
    })
    history.push({ role: 'system', content: systemPrompt })
  }
 
  // 3. 把用户的新消息追加到历史
  const userMsg: Message = { role: 'user', content: message }
  await appendMessage(c.env.KV, sessionId, userMsg)
  history.push(userMsg)
 
  // 4. 截断历史，控制在 Token 预算内
  const truncatedHistory = truncateByTokenBudget(
    history,
    INPUT_TOKEN_BUDGET,
    estimateMessagesTokens
  )
 
  // 5. 调用 LLM
  // 这里以 Cloudflare Workers AI 为例，换成 OpenAI API 也只是请求地址和格式不同
  const result = await c.env.AI.run('@cf/meta/llama-3.1-8b-instruct', {
    messages: truncatedHistory,
    max_tokens: 2048,
  })
 
  const assistantContent = (result as { response: string }).response
 
  // 6. 把 AI 的回答也存进历史
  const assistantMsg: Message = { role: 'assistant', content: assistantContent }
  await appendMessage(c.env.KV, sessionId, assistantMsg)
 
  // 7. 返回结果
  return c.json({
    sessionId,
    message: assistantContent,
  })
})
 
export default app

// src/routes/conversations.ts
import { Hono } from 'hono'
import { randomUUID } from 'crypto'
 
type Bindings = {
  KV: KVNamespace
}
 
const app = new Hono<{ Bindings: Bindings }>()
 
// 创建新会话
app.post('/api/conversations', (c) => {
  const sessionId = randomUUID()
  return c.json({ sessionId, createdAt: new Date().toISOString() })
})
 
// 获取会话历史（前端刷新页面后恢复对话用）
app.get('/api/conversations/:sessionId', async (c) => {
  const sessionId = c.req.param('sessionId')
  const raw = await c.env.KV.get(`conversation:${sessionId}`, 'json')
 
  if (!raw) {
    return c.json({ error: 'Conversation not found' }, 404)
  }
 
  return c.json({ sessionId, messages: raw })
})
 
// 删除会话（用户点「清除对话」）
app.delete('/api/conversations/:sessionId', async (c) => {
  const sessionId = c.req.param('sessionId')
  await c.env.KV.delete(`conversation:${sessionId}`)
  return c.json({ success: true })
})
 
export default app