feat(api): 添加后端 API 路由

- /api/chat: 流式聊天接口,支持 Claude API 调用
- /api/conversations: 会话列表和创建接口
- /api/conversations/[id]: 单个会话详情和删除
- /api/models: 可用模型列表接口
- /api/settings: 用户设置读写接口
- /api/tools: 可用工具列表接口
This commit is contained in:
gaoziman 2025-12-18 11:43:32 +08:00
parent ab9dd5aff8
commit bb5996240a
6 changed files with 963 additions and 0 deletions

555
src/app/api/chat/route.ts Normal file
View File

@ -0,0 +1,555 @@
import { NextResponse } from 'next/server';
import { db } from '@/drizzle/db';
import { conversations, messages, userSettings } from '@/drizzle/schema';
import { eq } from 'drizzle-orm';
import { nanoid } from 'nanoid';
import { executeTool } from '@/services/tools';
interface ChatRequest {
conversationId: string;
message: string;
model?: string;
tools?: string[];
enableThinking?: boolean;
}
// 消息内容块类型
interface ContentBlock {
type: 'text' | 'tool_use' | 'tool_result' | 'thinking';
text?: string;
thinking?: string;
id?: string;
name?: string;
input?: Record<string, unknown>;
tool_use_id?: string;
content?: string;
}
// API 消息类型
interface APIMessage {
role: 'user' | 'assistant';
content: string | ContentBlock[];
}
// 默认系统提示词 - 用于生成更详细、更有结构的回复
const DEFAULT_SYSTEM_PROMPT = `你是一个专业、友好的 AI 助手。请遵循以下规则来回复用户:
## 📅
**** {{CURRENT_DATE}}使
## 🎯
****
1. ****
2. ****
-
-
3. ****使
4. ****
##
- 使
-
-
##
- 使 Markdown
- 使 \`\`\`python
- 使#####
- 使
- 使
##
1. ****
2. ****
3. ****
4. ****
5. ****
##
-
-
- 使
-
## 使
- 使 web_search
- 使 code_execution
- 使 web_fetch
- ****
##
使
1. ****
2. ****"来源""参考"
3. ****
- "今天北京天气晴朗气温15°C。来源weather.com"
-
4. ****
##
-
-
- `;
// POST /api/chat - 发送消息并获取 AI 回复
export async function POST(request: Request) {
try {
const body: ChatRequest = await request.json();
const { conversationId, message, model, tools, enableThinking } = body;
// 获取用户设置
const settings = await db.query.userSettings.findFirst({
where: eq(userSettings.id, 1),
});
if (!settings?.cchApiKey) {
return NextResponse.json(
{ error: 'Please configure your CCH API key in settings' },
{ status: 400 }
);
}
// 获取对话信息
const conversation = await db.query.conversations.findFirst({
where: eq(conversations.conversationId, conversationId),
});
if (!conversation) {
return NextResponse.json(
{ error: 'Conversation not found' },
{ status: 404 }
);
}
// 获取对话历史消息
const historyMessages = await db.query.messages.findMany({
where: eq(messages.conversationId, conversationId),
orderBy: (messages, { asc }) => [asc(messages.createdAt)],
});
// 保存用户消息
const userMessageId = nanoid();
await db.insert(messages).values({
messageId: userMessageId,
conversationId,
role: 'user',
content: message,
status: 'completed',
});
// 构建消息历史
const messageHistory: APIMessage[] = historyMessages.map((msg) => ({
role: msg.role as 'user' | 'assistant',
content: msg.content,
}));
// 添加当前用户消息
messageHistory.push({
role: 'user',
content: message,
});
// 准备 AI 消息 ID
const assistantMessageId = nanoid();
// 创建 SSE 响应
const encoder = new TextEncoder();
const stream = new ReadableStream({
async start(controller) {
try {
// 调用 CCH API
const cchUrl = settings.cchUrl || 'http://localhost:13500';
const useThinking = enableThinking ?? conversation.enableThinking;
const useModel = model || conversation.model;
// 构建工具定义(如果需要)
const toolDefinitions = buildToolDefinitions(tools || (conversation.tools as string[]) || []);
// 获取系统提示词(优先级:对话级别 > 全局设置 > 默认)
const baseSystemPrompt = conversation.systemPrompt || settings.systemPrompt || DEFAULT_SYSTEM_PROMPT;
// 替换日期占位符为当前日期
const currentDate = new Date().toLocaleDateString('zh-CN', {
year: 'numeric',
month: 'long',
day: 'numeric',
weekday: 'long',
});
const systemPrompt = baseSystemPrompt.replace('{{CURRENT_DATE}}', currentDate);
// 获取温度参数(优先级:对话级别 > 全局设置 > 默认 0.7
const temperature = parseFloat(conversation.temperature || settings.temperature || '0.7');
// 工具执行循环
let currentMessages = [...messageHistory];
let fullContent = '';
let thinkingContent = '';
let totalInputTokens = 0;
let totalOutputTokens = 0;
let loopCount = 0;
const maxLoops = 10; // 防止无限循环
let hasToolResults = false; // 标记是否有工具结果
while (loopCount < maxLoops) {
loopCount++;
// 构建请求体
const requestBody: Record<string, unknown> = {
model: useModel,
max_tokens: 8192,
stream: true,
system: systemPrompt,
messages: currentMessages,
};
// 添加工具
if (toolDefinitions.length > 0) {
requestBody.tools = toolDefinitions;
}
// 添加思考模式
// 重要thinking 模式和工具调用的 tool_result 不兼容
// 当消息中包含 tool_result 时,不能启用 thinking 模式
if (useThinking && !hasToolResults) {
requestBody.thinking = {
type: 'enabled',
budget_tokens: 4096,
};
} else {
requestBody.temperature = temperature;
}
const response = await fetch(`${cchUrl}/v1/messages`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'x-api-key': settings.cchApiKey!,
'anthropic-version': '2023-06-01',
},
body: JSON.stringify(requestBody),
});
if (!response.ok) {
const errorText = await response.text();
throw new Error(`CCH API error: ${response.status} - ${errorText}`);
}
const reader = response.body?.getReader();
if (!reader) {
throw new Error('No response body');
}
// 收集当前轮次的内容
let currentTextContent = '';
let currentThinkingContent = '';
const toolCalls: { id: string; name: string; input: Record<string, unknown> }[] = [];
let currentToolUse: { id: string; name: string; inputJson: string } | null = null;
let stopReason: string | null = null;
const decoder = new TextDecoder();
let buffer = '';
// 处理流式响应
while (true) {
const { done, value } = await reader.read();
if (done) break;
buffer += decoder.decode(value, { stream: true });
const lines = buffer.split('\n');
buffer = lines.pop() || '';
for (const line of lines) {
if (line.startsWith('data: ')) {
const data = line.slice(6);
if (data === '[DONE]') continue;
try {
const event = JSON.parse(data);
if (event.type === 'content_block_delta') {
const delta = event.delta;
if (delta.type === 'thinking_delta') {
currentThinkingContent += delta.thinking || '';
thinkingContent += delta.thinking || '';
controller.enqueue(encoder.encode(`data: ${JSON.stringify({
type: 'thinking',
content: delta.thinking || '',
})}\n\n`));
} else if (delta.type === 'text_delta') {
currentTextContent += delta.text || '';
fullContent += delta.text || '';
controller.enqueue(encoder.encode(`data: ${JSON.stringify({
type: 'text',
content: delta.text || '',
})}\n\n`));
} else if (delta.type === 'input_json_delta') {
if (currentToolUse) {
currentToolUse.inputJson += delta.partial_json || '';
}
}
} else if (event.type === 'message_delta') {
if (event.usage) {
totalOutputTokens += event.usage.output_tokens || 0;
}
if (event.delta?.stop_reason) {
stopReason = event.delta.stop_reason;
}
} else if (event.type === 'message_start') {
if (event.message?.usage) {
totalInputTokens += event.message.usage.input_tokens || 0;
}
} else if (event.type === 'content_block_start') {
if (event.content_block?.type === 'tool_use') {
currentToolUse = {
id: event.content_block.id,
name: event.content_block.name,
inputJson: '',
};
controller.enqueue(encoder.encode(`data: ${JSON.stringify({
type: 'tool_use_start',
id: event.content_block.id,
name: event.content_block.name,
})}\n\n`));
}
} else if (event.type === 'content_block_stop') {
if (currentToolUse) {
try {
const toolInput = JSON.parse(currentToolUse.inputJson || '{}');
toolCalls.push({
id: currentToolUse.id,
name: currentToolUse.name,
input: toolInput,
});
controller.enqueue(encoder.encode(`data: ${JSON.stringify({
type: 'tool_use_complete',
id: currentToolUse.id,
name: currentToolUse.name,
input: toolInput,
})}\n\n`));
} catch (e) {
console.error('Failed to parse tool input:', e);
}
currentToolUse = null;
}
}
} catch (e) {
console.error('Parse error:', e);
}
}
}
}
// 检查是否需要执行工具
if (stopReason === 'tool_use' && toolCalls.length > 0) {
// 构建助手消息的内容块
const assistantContent: ContentBlock[] = [];
// 如果有 thinking 内容需要先添加Claude API 要求)
if (currentThinkingContent) {
assistantContent.push({
type: 'thinking',
thinking: currentThinkingContent,
});
}
if (currentTextContent) {
assistantContent.push({
type: 'text',
text: currentTextContent,
});
}
// 添加工具调用
for (const tc of toolCalls) {
assistantContent.push({
type: 'tool_use',
id: tc.id,
name: tc.name,
input: tc.input,
});
}
// 将助手消息添加到历史
currentMessages.push({
role: 'assistant',
content: assistantContent,
});
// 执行所有工具并收集结果
const toolResults: ContentBlock[] = [];
for (const tc of toolCalls) {
// 发送工具执行开始事件
controller.enqueue(encoder.encode(`data: ${JSON.stringify({
type: 'tool_execution_start',
id: tc.id,
name: tc.name,
})}\n\n`));
// 执行工具
const result = await executeTool(tc.name, tc.input);
// 发送工具执行结果事件(使用简短版本)
controller.enqueue(encoder.encode(`data: ${JSON.stringify({
type: 'tool_execution_result',
id: tc.id,
name: tc.name,
success: result.success,
result: result.displayResult,
})}\n\n`));
// 将简短的工具结果显示给用户
const toolDisplayText = `\n\n${result.displayResult}\n\n`;
fullContent += toolDisplayText;
controller.enqueue(encoder.encode(`data: ${JSON.stringify({
type: 'text',
content: toolDisplayText,
})}\n\n`));
// 将完整的工具结果发送给 AI
toolResults.push({
type: 'tool_result',
tool_use_id: tc.id,
content: result.fullResult,
});
}
// 将工具结果添加到消息历史
currentMessages.push({
role: 'user',
content: toolResults,
});
// 标记已有工具结果,下一轮请求需要禁用 thinking 模式
hasToolResults = true;
// 继续循环,让 AI 基于工具结果继续回复
continue;
}
// 如果没有工具调用或停止原因不是 tool_use则结束循环
break;
}
// 保存 AI 回复到数据库
await db.insert(messages).values({
messageId: assistantMessageId,
conversationId,
role: 'assistant',
content: fullContent,
thinkingContent: thinkingContent || null,
inputTokens: totalInputTokens,
outputTokens: totalOutputTokens,
status: 'completed',
});
// 更新对话信息
await db
.update(conversations)
.set({
messageCount: (conversation.messageCount || 0) + 2,
totalTokens: (conversation.totalTokens || 0) + totalInputTokens + totalOutputTokens,
lastMessageAt: new Date(),
updatedAt: new Date(),
title: (conversation.messageCount || 0) === 0
? message.slice(0, 50) + (message.length > 50 ? '...' : '')
: conversation.title,
})
.where(eq(conversations.conversationId, conversationId));
// 发送完成事件
controller.enqueue(encoder.encode(`data: ${JSON.stringify({
type: 'done',
messageId: assistantMessageId,
inputTokens: totalInputTokens,
outputTokens: totalOutputTokens,
})}\n\n`));
controller.close();
} catch (error) {
console.error('Stream error:', error);
const errorMessage = error instanceof Error ? error.message : 'Unknown error';
controller.enqueue(encoder.encode(`data: ${JSON.stringify({
type: 'error',
error: errorMessage,
})}\n\n`));
controller.close();
}
},
});
return new Response(stream, {
headers: {
'Content-Type': 'text/event-stream',
'Cache-Control': 'no-cache',
'Connection': 'keep-alive',
},
});
} catch (error) {
console.error('Chat API error:', error);
return NextResponse.json(
{ error: 'Failed to process chat request' },
{ status: 500 }
);
}
}
// 构建工具定义
function buildToolDefinitions(toolIds: string[]) {
const toolMap: Record<string, object> = {
web_search: {
name: 'web_search',
description: '搜索互联网获取最新信息。当用户询问时事、新闻、天气、实时数据等需要最新信息的问题时,请使用此工具。',
input_schema: {
type: 'object',
properties: {
query: {
type: 'string',
description: '搜索查询关键词',
},
},
required: ['query'],
},
},
code_execution: {
name: 'code_execution',
description: '执行代码并返回结果。支持 Python、JavaScript、TypeScript、Java、C、C++、Go、Rust 等多种语言。当需要验证代码、进行计算或演示代码运行结果时,请使用此工具。',
input_schema: {
type: 'object',
properties: {
code: {
type: 'string',
description: '要执行的代码',
},
language: {
type: 'string',
description: '编程语言 (python, javascript, typescript, java, c, cpp, go, rust, ruby, php 等)',
},
},
required: ['code', 'language'],
},
},
web_fetch: {
name: 'web_fetch',
description: '获取指定 URL 的网页内容。当用户提供了具体的网址并想了解该页面的内容时,请使用此工具。',
input_schema: {
type: 'object',
properties: {
url: {
type: 'string',
description: '要获取内容的完整 URL',
},
},
required: ['url'],
},
},
};
return toolIds
.filter((id) => toolMap[id])
.map((id) => toolMap[id]);
}

View File

@ -0,0 +1,119 @@
import { NextResponse } from 'next/server';
import { db } from '@/drizzle/db';
import { conversations, messages } from '@/drizzle/schema';
import { eq, asc } from 'drizzle-orm';
interface RouteParams {
params: Promise<{ id: string }>;
}
// GET /api/conversations/[id] - 获取单个对话及其消息
export async function GET(request: Request, { params }: RouteParams) {
try {
const { id } = await params;
const conversation = await db.query.conversations.findFirst({
where: eq(conversations.conversationId, id),
});
if (!conversation) {
return NextResponse.json(
{ error: 'Conversation not found' },
{ status: 404 }
);
}
const messageList = await db.query.messages.findMany({
where: eq(messages.conversationId, id),
orderBy: [asc(messages.createdAt)],
});
return NextResponse.json({
...conversation,
messages: messageList,
});
} catch (error) {
console.error('Failed to get conversation:', error);
return NextResponse.json(
{ error: 'Failed to get conversation' },
{ status: 500 }
);
}
}
// PUT /api/conversations/[id] - 更新对话
export async function PUT(request: Request, { params }: RouteParams) {
try {
const { id } = await params;
const body = await request.json();
const { title, isPinned, isArchived } = body;
const updateData: Record<string, unknown> = {
updatedAt: new Date(),
};
if (title !== undefined) {
updateData.title = title;
}
if (isPinned !== undefined) {
updateData.isPinned = isPinned;
}
if (isArchived !== undefined) {
updateData.isArchived = isArchived;
}
const [updated] = await db
.update(conversations)
.set(updateData)
.where(eq(conversations.conversationId, id))
.returning();
if (!updated) {
return NextResponse.json(
{ error: 'Conversation not found' },
{ status: 404 }
);
}
return NextResponse.json(updated);
} catch (error) {
console.error('Failed to update conversation:', error);
return NextResponse.json(
{ error: 'Failed to update conversation' },
{ status: 500 }
);
}
}
// DELETE /api/conversations/[id] - 删除对话
export async function DELETE(request: Request, { params }: RouteParams) {
try {
const { id } = await params;
// 先删除相关消息
await db.delete(messages).where(eq(messages.conversationId, id));
// 再删除对话
const [deleted] = await db
.delete(conversations)
.where(eq(conversations.conversationId, id))
.returning();
if (!deleted) {
return NextResponse.json(
{ error: 'Conversation not found' },
{ status: 404 }
);
}
return NextResponse.json({ success: true });
} catch (error) {
console.error('Failed to delete conversation:', error);
return NextResponse.json(
{ error: 'Failed to delete conversation' },
{ status: 500 }
);
}
}

View File

@ -0,0 +1,81 @@
import { NextResponse } from 'next/server';
import { db } from '@/drizzle/db';
import { conversations, messages } from '@/drizzle/schema';
import { desc, eq } from 'drizzle-orm';
import { nanoid } from 'nanoid';
// GET /api/conversations - 获取对话列表
export async function GET() {
try {
const conversationList = await db.query.conversations.findMany({
where: eq(conversations.isArchived, false),
orderBy: [desc(conversations.lastMessageAt)],
});
return NextResponse.json(conversationList);
} catch (error) {
console.error('Failed to get conversations:', error);
return NextResponse.json(
{ error: 'Failed to get conversations' },
{ status: 500 }
);
}
}
// POST /api/conversations - 创建新对话
export async function POST(request: Request) {
try {
const body = await request.json();
const { title, model, tools, enableThinking } = body;
const conversationId = nanoid();
const [newConversation] = await db
.insert(conversations)
.values({
conversationId,
title: title || '新对话',
model: model || 'claude-sonnet-4-20250514',
tools: tools || [],
enableThinking: enableThinking || false,
})
.returning();
return NextResponse.json(newConversation, { status: 201 });
} catch (error) {
console.error('Failed to create conversation:', error);
return NextResponse.json(
{ error: 'Failed to create conversation' },
{ status: 500 }
);
}
}
// DELETE /api/conversations - 批量删除对话
export async function DELETE(request: Request) {
try {
const body = await request.json();
const { conversationIds } = body;
if (!conversationIds || !Array.isArray(conversationIds)) {
return NextResponse.json(
{ error: 'conversationIds array is required' },
{ status: 400 }
);
}
// 删除相关消息
for (const id of conversationIds) {
await db.delete(messages).where(eq(messages.conversationId, id));
await db.delete(conversations).where(eq(conversations.conversationId, id));
}
return NextResponse.json({ success: true });
} catch (error) {
console.error('Failed to delete conversations:', error);
return NextResponse.json(
{ error: 'Failed to delete conversations' },
{ status: 500 }
);
}
}

View File

@ -0,0 +1,22 @@
import { NextResponse } from 'next/server';
import { db } from '@/drizzle/db';
import { models } from '@/drizzle/schema';
import { eq, asc } from 'drizzle-orm';
// GET /api/models - 获取所有模型列表
export async function GET() {
try {
const modelList = await db.query.models.findMany({
where: eq(models.isEnabled, true),
orderBy: [asc(models.sortOrder)],
});
return NextResponse.json(modelList);
} catch (error) {
console.error('Failed to get models:', error);
return NextResponse.json(
{ error: 'Failed to get models' },
{ status: 500 }
);
}
}

View File

@ -0,0 +1,164 @@
import { NextResponse } from 'next/server';
import { db } from '@/drizzle/db';
import { userSettings } from '@/drizzle/schema';
import { eq } from 'drizzle-orm';
// GET /api/settings - 获取用户设置
export async function GET() {
try {
const settings = await db.query.userSettings.findFirst({
where: eq(userSettings.id, 1),
});
if (!settings) {
// 如果没有设置,返回默认值
return NextResponse.json({
cchUrl: process.env.CCH_DEFAULT_URL || 'http://localhost:13500',
cchApiKeyConfigured: false,
defaultModel: 'claude-sonnet-4-20250514',
defaultTools: ['web_search', 'code_execution', 'web_fetch'],
systemPrompt: '',
temperature: '0.7',
theme: 'light',
language: 'zh-CN',
enableThinking: false,
saveChatHistory: true,
});
}
// 不返回 API Key 本身,只返回是否已配置
return NextResponse.json({
cchUrl: settings.cchUrl,
cchApiKeyConfigured: settings.cchApiKeyConfigured,
defaultModel: settings.defaultModel,
defaultTools: settings.defaultTools,
systemPrompt: settings.systemPrompt || '',
temperature: settings.temperature || '0.7',
theme: settings.theme,
language: settings.language,
enableThinking: settings.enableThinking,
saveChatHistory: settings.saveChatHistory,
});
} catch (error) {
console.error('Failed to get settings:', error);
return NextResponse.json(
{ error: 'Failed to get settings' },
{ status: 500 }
);
}
}
// PUT /api/settings - 更新用户设置
export async function PUT(request: Request) {
try {
const body = await request.json();
const {
cchUrl,
cchApiKey,
defaultModel,
defaultTools,
systemPrompt,
temperature,
theme,
language,
enableThinking,
saveChatHistory,
} = body;
// 构建更新对象
const updateData: Record<string, unknown> = {
updatedAt: new Date(),
};
if (cchUrl !== undefined) {
updateData.cchUrl = cchUrl;
}
// 如果提供了 API Key更新它
if (cchApiKey !== undefined) {
if (cchApiKey === '') {
// 清除 API Key
updateData.cchApiKey = null;
updateData.cchApiKeyConfigured = false;
} else {
updateData.cchApiKey = cchApiKey;
updateData.cchApiKeyConfigured = true;
}
}
if (defaultModel !== undefined) {
updateData.defaultModel = defaultModel;
}
if (defaultTools !== undefined) {
updateData.defaultTools = defaultTools;
}
if (systemPrompt !== undefined) {
updateData.systemPrompt = systemPrompt;
}
if (temperature !== undefined) {
updateData.temperature = temperature;
}
if (theme !== undefined) {
updateData.theme = theme;
}
if (language !== undefined) {
updateData.language = language;
}
if (enableThinking !== undefined) {
updateData.enableThinking = enableThinking;
}
if (saveChatHistory !== undefined) {
updateData.saveChatHistory = saveChatHistory;
}
// 检查是否存在设置记录
const existing = await db.query.userSettings.findFirst({
where: eq(userSettings.id, 1),
});
if (!existing) {
// 创建新的设置记录
await db.insert(userSettings).values({
id: 1,
...updateData,
});
} else {
// 更新现有记录
await db
.update(userSettings)
.set(updateData)
.where(eq(userSettings.id, 1));
}
// 返回更新后的设置(不包含 API Key
const updatedSettings = await db.query.userSettings.findFirst({
where: eq(userSettings.id, 1),
});
return NextResponse.json({
cchUrl: updatedSettings?.cchUrl,
cchApiKeyConfigured: updatedSettings?.cchApiKeyConfigured,
defaultModel: updatedSettings?.defaultModel,
defaultTools: updatedSettings?.defaultTools,
systemPrompt: updatedSettings?.systemPrompt || '',
temperature: updatedSettings?.temperature || '0.7',
theme: updatedSettings?.theme,
language: updatedSettings?.language,
enableThinking: updatedSettings?.enableThinking,
saveChatHistory: updatedSettings?.saveChatHistory,
});
} catch (error) {
console.error('Failed to update settings:', error);
return NextResponse.json(
{ error: 'Failed to update settings' },
{ status: 500 }
);
}
}

View File

@ -0,0 +1,22 @@
import { NextResponse } from 'next/server';
import { db } from '@/drizzle/db';
import { tools } from '@/drizzle/schema';
import { eq, asc } from 'drizzle-orm';
// GET /api/tools - 获取所有工具列表
export async function GET() {
try {
const toolList = await db.query.tools.findMany({
where: eq(tools.isEnabled, true),
orderBy: [asc(tools.sortOrder)],
});
return NextResponse.json(toolList);
} catch (error) {
console.error('Failed to get tools:', error);
return NextResponse.json(
{ error: 'Failed to get tools' },
{ status: 500 }
);
}
}