feat: 工作台聊天室功能

src/server/ai/agent-stream.ts

@@ -0,0 +1,71 @@
+import type { ModelMessage } from "ai";
+import type Database from "bun:sqlite";
+
+import { stepCountIs, streamText } from "ai";
+import { eq } from "drizzle-orm";
+
+import { wrap } from "../db/connection";
+import { models, providers } from "../db/schema";
+import { buildProviderRegistry } from "./registry";
+
+const SYSTEM_PROMPT = "你是 Alfred 的 AI 助手。你可以帮助用户回答问题、分析数据和完成各种任务。请用中文回复。";
+
+export interface AgentStreamOptions {
+  db: Database;
+  messages: IncomingMessage[];
+  modelDbId: string;
+}
+
+export interface IncomingMessage {
+  content?: string;
+  id?: string;
+  parts?: Array<{ text?: string; type: string }>;
+  role?: string;
+}
+
+export function agentStream(options: AgentStreamOptions) {
+  const db = wrap(options.db);
+
+  const modelRow = db.select().from(models).where(eq(models.id, options.modelDbId)).get();
+  if (!modelRow) throw new Error(`模型不存在: ${options.modelDbId}`);
+
+  const providerRow = db.select().from(providers).where(eq(providers.id, modelRow.providerId)).get();
+  if (!providerRow) throw new Error(`供应商不存在: ${modelRow.providerId}`);
+
+  const registry = buildProviderRegistry(options.db);
+  const model = registry.languageModel(`${providerRow.id}:${modelRow.modelId}`);
+
+  return streamText({
+    messages: toCoreMessages(options.messages),
+    model,
+    stopWhen: stepCountIs(1),
+    system: SYSTEM_PROMPT,
+  });
+}
+
+export function extractTextContent(msg: IncomingMessage): string {
+  return (
+    msg.content ??
+    (Array.isArray(msg.parts)
+      ? msg.parts
+          .filter((p) => p.type === "text" && typeof p.text === "string")
+          .map((p) => p.text!)
+          .join("")
+      : "")
+  );
+}
+
+function toCoreMessages(messages: IncomingMessage[]): ModelMessage[] {
+  return messages.map((msg) => {
+    const content =
+      msg.content ??
+      (Array.isArray(msg.parts)
+        ? msg.parts
+            .filter((p) => p.type === "text" && typeof p.text === "string")
+            .map((p) => p.text!)
+            .join("")
+        : "");
+
+    return { content, role: msg.role as ModelMessage["role"] } as ModelMessage;
+  });
+}

src/server/db/conversations.ts

@@ -0,0 +1,178 @@
+import type Database from "bun:sqlite";
+
+import { desc, eq } from "drizzle-orm";
+
+import type { Conversation, Message } from "../../shared/api";
+
+import { paginateQuery, wrap } from "./connection";
+import { conversations, messages, models } from "./schema";
+
+export function createConversation(
+  raw: Database,
+  projectId: string,
+  defaultModelId?: string,
+): { conversation: Conversation } | { error: string; status: number } {
+  const db = wrap(raw);
+
+  let modelId = defaultModelId;
+  if (!modelId) {
+    const firstModel = db.select().from(models).limit(1).get();
+    if (!firstModel) return { error: "没有可用的模型，请先配置模型", status: 400 };
+    modelId = firstModel.id;
+  } else {
+    const model = db.select().from(models).where(eq(models.id, modelId)).get();
+    if (!model) return { error: "模型不存在", status: 400 };
+  }
+
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+
+  db.insert(conversations)
+    .values({
+      createdAt: now,
+      id,
+      modelId,
+      projectId,
+      title: "新会话",
+      updatedAt: now,
+    })
+    .run();
+
+  const row = db.select().from(conversations).where(eq(conversations.id, id)).get();
+  return { conversation: toConversation(row!) };
+}
+
+export function createMessage(
+  raw: Database,
+  data: {
+    content: string;
+    conversationId: string;
+    parts?: string;
+    role: "assistant" | "system" | "user";
+  },
+): Message {
+  const db = wrap(raw);
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+
+  db.insert(messages)
+    .values({
+      content: data.content,
+      conversationId: data.conversationId,
+      createdAt: now,
+      id,
+      parts: data.parts ?? null,
+      role: data.role,
+    })
+    .run();
+
+  const row = db.select().from(messages).where(eq(messages.id, id)).get();
+  return toMessage(row!);
+}
+
+export function createMessages(
+  raw: Database,
+  data: Array<{
+    content: string;
+    conversationId: string;
+    parts?: string;
+    role: "assistant" | "system" | "user";
+  }>,
+): Message[] {
+  const db = wrap(raw);
+  const now = new Date().toISOString();
+  const results: Message[] = [];
+
+  for (const item of data) {
+    const id = crypto.randomUUID();
+    db.insert(messages)
+      .values({
+        content: item.content,
+        conversationId: item.conversationId,
+        createdAt: now,
+        id,
+        parts: item.parts ?? null,
+        role: item.role,
+      })
+      .run();
+    const row = db.select().from(messages).where(eq(messages.id, id)).get();
+    results.push(toMessage(row!));
+  }
+
+  return results;
+}
+
+export function deleteConversation(raw: Database, id: string): { error: string; status: number } | { success: true } {
+  const db = wrap(raw);
+  const existing = db.select().from(conversations).where(eq(conversations.id, id)).get();
+  if (!existing) return { error: "会话不存在", status: 404 };
+
+  db.delete(messages).where(eq(messages.conversationId, id)).run();
+  db.delete(conversations).where(eq(conversations.id, id)).run();
+  return { success: true };
+}
+
+export function getConversation(
+  raw: Database,
+  id: string,
+): { conversation: Conversation } | { error: string; status: number } {
+  const db = wrap(raw);
+  const row = db.select().from(conversations).where(eq(conversations.id, id)).get();
+  if (!row) return { error: "会话不存在", status: 404 };
+  return { conversation: toConversation(row) };
+}
+
+export function listConversations(
+  raw: Database,
+  projectId: string,
+  options: { page: number; pageSize: number },
+): { items: Conversation[]; page: number; pageSize: number; total: number } {
+  return paginateQuery(raw, conversations, {
+    conditions: [eq(conversations.projectId, projectId)],
+    mapRow: toConversation,
+    orderBy: () => desc(conversations.updatedAt),
+    page: options.page,
+    pageSize: options.pageSize,
+  });
+}
+
+export function listMessages(
+  raw: Database,
+  conversationId: string,
+  options: { page: number; pageSize: number },
+): { items: Message[]; page: number; pageSize: number; total: number } {
+  return paginateQuery(raw, messages, {
+    conditions: [eq(messages.conversationId, conversationId)],
+    mapRow: toMessage,
+    orderBy: () => desc(messages.createdAt),
+    page: options.page,
+    pageSize: options.pageSize,
+  });
+}
+
+export function updateConversationTimestamp(raw: Database, id: string): void {
+  const db = wrap(raw);
+  db.update(conversations).set({ updatedAt: new Date().toISOString() }).where(eq(conversations.id, id)).run();
+}
+
+function toConversation(row: typeof conversations.$inferSelect): Conversation {
+  return {
+    createdAt: row.createdAt,
+    id: row.id,
+    modelId: row.modelId,
+    projectId: row.projectId,
+    title: row.title,
+    updatedAt: row.updatedAt,
+  };
+}
+
+function toMessage(row: typeof messages.$inferSelect): Message {
+  return {
+    content: row.content,
+    conversationId: row.conversationId,
+    createdAt: row.createdAt,
+    id: row.id,
+    parts: row.parts,
+    role: row.role,
+  };
+}

src/server/db/index.ts

@@ -1,4 +1,14 @@
 export { createDatabase } from "./connection";
+export {
+  createConversation,
+  createMessage,
+  createMessages,
+  deleteConversation,
+  getConversation,
+  listConversations,
+  listMessages,
+  updateConversationTimestamp,
+} from "./conversations";
 export { loadMigrationsFromDir, type MigrationRecord } from "./load-migrations";
 export { runMigrations } from "./migrate";
-export { projects, schemaMigrations } from "./schema";
+export { conversations, messages, projects, schemaMigrations } from "./schema";

src/server/db/schema.ts

@@ -45,6 +45,38 @@ export const models = sqliteTable(
   ],
 );
 
+export const conversations = sqliteTable(
+  "conversations",
+  {
+    createdAt: text("created_at").notNull(),
+    id: text("id").primaryKey(),
+    modelId: text("model_id")
+      .notNull()
+      .references(() => models.id),
+    projectId: text("project_id")
+      .notNull()
+      .references(() => projects.id),
+    title: text("title").notNull().default("新会话"),
+    updatedAt: text("updated_at").notNull(),
+  },
+  (table) => [index("conversations_project_id_idx").on(table.projectId)],
+);
+
+export const messages = sqliteTable(
+  "messages",
+  {
+    content: text("content").notNull().default(""),
+    conversationId: text("conversation_id")
+      .notNull()
+      .references(() => conversations.id, { onDelete: "cascade" }),
+    createdAt: text("created_at").notNull(),
+    id: text("id").primaryKey(),
+    parts: text("parts"),
+    role: text("role", { enum: ["assistant", "system", "user"] }).notNull(),
+  },
+  (table) => [index("messages_conversation_id_idx").on(table.conversationId)],
+);
+
 export const schemaMigrations = sqliteTable("schema_migrations", {
   appliedAt: text("applied_at").notNull(),
   checksum: text("checksum").notNull(),

src/server/routes/chat/create.ts

@@ -0,0 +1,29 @@
+import type Database from "bun:sqlite";
+
+import type { CreateConversationRequest, RuntimeMode } from "../../../shared/api";
+
+import { createConversation } from "../../db/conversations";
+import { createApiError, jsonResponse } from "../../helpers";
+import { validateIdParam } from "../../middleware";
+
+export async function handleCreateConversation(req: Request, db: Database, mode: RuntimeMode): Promise<Response> {
+  const url = new URL(req.url);
+  const projectId = url.pathname.split("/")[3];
+
+  const validated = validateIdParam(projectId ?? "", mode);
+  if (validated instanceof Response) return validated;
+
+  let body: CreateConversationRequest = {};
+  try {
+    body = (await req.json()) as CreateConversationRequest;
+  } catch {
+    // empty body is ok, defaults will be used
+  }
+
+  const result = createConversation(db, validated.id, body.modelId);
+  if ("error" in result) {
+    return jsonResponse(createApiError(result.error, result.status), { mode, status: result.status });
+  }
+
+  return jsonResponse({ conversation: result.conversation }, { mode, status: 201 });
+}

src/server/routes/chat/delete.ts

@@ -0,0 +1,35 @@
+import type Database from "bun:sqlite";
+
+import type { RuntimeMode } from "../../../shared/api";
+
+import { deleteConversation, getConversation } from "../../db/conversations";
+import { createApiError, jsonResponse } from "../../helpers";
+import { validateIdParam } from "../../middleware";
+
+export function handleDeleteConversation(req: Request, db: Database, mode: RuntimeMode): Response {
+  const parts = new URL(req.url).pathname.split("/");
+  const projectId = parts[3];
+  const conversationId = parts[5];
+
+  const validatedProject = validateIdParam(projectId ?? "", mode);
+  if (validatedProject instanceof Response) return validatedProject;
+
+  const validatedConv = validateIdParam(conversationId ?? "", mode);
+  if (validatedConv instanceof Response) return validatedConv;
+
+  const convResult = getConversation(db, validatedConv.id);
+  if ("error" in convResult) {
+    return jsonResponse(createApiError(convResult.error, convResult.status), { mode, status: convResult.status });
+  }
+
+  if (convResult.conversation.projectId !== validatedProject.id) {
+    return jsonResponse(createApiError("会话不属于该项目", 403), { mode, status: 403 });
+  }
+
+  const result = deleteConversation(db, validatedConv.id);
+  if ("error" in result) {
+    return jsonResponse(createApiError(result.error, result.status), { mode, status: result.status });
+  }
+
+  return jsonResponse({ success: true }, { mode });
+}

src/server/routes/chat/get.ts

@@ -0,0 +1,30 @@
+import type Database from "bun:sqlite";
+
+import type { RuntimeMode } from "../../../shared/api";
+
+import { getConversation } from "../../db/conversations";
+import { createApiError, jsonResponse } from "../../helpers";
+import { validateIdParam } from "../../middleware";
+
+export function handleGetConversation(req: Request, db: Database, mode: RuntimeMode): Response {
+  const parts = new URL(req.url).pathname.split("/");
+  const projectId = parts[3];
+  const conversationId = parts[5];
+
+  const validatedProject = validateIdParam(projectId ?? "", mode);
+  if (validatedProject instanceof Response) return validatedProject;
+
+  const validatedConv = validateIdParam(conversationId ?? "", mode);
+  if (validatedConv instanceof Response) return validatedConv;
+
+  const result = getConversation(db, validatedConv.id);
+  if ("error" in result) {
+    return jsonResponse(createApiError(result.error, result.status), { mode, status: result.status });
+  }
+
+  if (result.conversation.projectId !== validatedProject.id) {
+    return jsonResponse(createApiError("会话不属于该项目", 403), { mode, status: 403 });
+  }
+
+  return jsonResponse({ conversation: result.conversation }, { mode });
+}

src/server/routes/chat/list.ts

@@ -0,0 +1,28 @@
+import type Database from "bun:sqlite";
+
+import type { RuntimeMode } from "../../../shared/api";
+
+import { listConversations } from "../../db/conversations";
+import { jsonResponse } from "../../helpers";
+import { validateIdParam, validatePagination } from "../../middleware";
+
+export function handleListConversations(req: Request, db: Database, mode: RuntimeMode): Response {
+  const url = new URL(req.url);
+  const projectId = url.pathname.split("/")[3];
+
+  const validated = validateIdParam(projectId ?? "", mode);
+  if (validated instanceof Response) return validated;
+
+  const pageParam = url.searchParams.get("page");
+  const pageSizeParam = url.searchParams.get("pageSize");
+
+  const pagination = validatePagination(pageParam, pageSizeParam, mode);
+  if (pagination instanceof Response) return pagination;
+
+  const result = listConversations(db, validated.id, {
+    page: pagination.page,
+    pageSize: pagination.pageSize,
+  });
+
+  return jsonResponse(result, { mode });
+}

src/server/routes/chat/messages.ts

@@ -0,0 +1,42 @@
+import type Database from "bun:sqlite";
+
+import type { RuntimeMode } from "../../../shared/api";
+
+import { getConversation, listMessages } from "../../db/conversations";
+import { createApiError, jsonResponse } from "../../helpers";
+import { validateIdParam, validatePagination } from "../../middleware";
+
+export function handleListMessages(req: Request, db: Database, mode: RuntimeMode): Response {
+  const parts = new URL(req.url).pathname.split("/");
+  const projectId = parts[3];
+  const conversationId = parts[5];
+
+  const validatedProject = validateIdParam(projectId ?? "", mode);
+  if (validatedProject instanceof Response) return validatedProject;
+
+  const validatedConv = validateIdParam(conversationId ?? "", mode);
+  if (validatedConv instanceof Response) return validatedConv;
+
+  const convResult = getConversation(db, validatedConv.id);
+  if ("error" in convResult) {
+    return jsonResponse(createApiError(convResult.error, convResult.status), { mode, status: convResult.status });
+  }
+
+  if (convResult.conversation.projectId !== validatedProject.id) {
+    return jsonResponse(createApiError("会话不属于该项目", 403), { mode, status: 403 });
+  }
+
+  const url = new URL(req.url);
+  const pageParam = url.searchParams.get("page");
+  const pageSizeParam = url.searchParams.get("pageSize");
+
+  const pagination = validatePagination(pageParam, pageSizeParam, mode);
+  if (pagination instanceof Response) return pagination;
+
+  const result = listMessages(db, validatedConv.id, {
+    page: pagination.page,
+    pageSize: pagination.pageSize,
+  });
+
+  return jsonResponse(result, { mode });
+}

src/server/routes/chat/send.ts

@@ -0,0 +1,91 @@
+import type Database from "bun:sqlite";
+
+import type { RuntimeMode } from "../../../shared/api";
+import type { IncomingMessage } from "../../ai/agent-stream";
+
+import { agentStream, extractTextContent } from "../../ai/agent-stream";
+import { createMessage, getConversation, updateConversationTimestamp } from "../../db/conversations";
+import { createApiError, jsonResponse } from "../../helpers";
+import { validateIdParam } from "../../middleware";
+
+export async function handleSendChat(req: Request, db: Database, mode: RuntimeMode): Promise<Response> {
+  const url = new URL(req.url);
+  const projectId = url.pathname.split("/")[3];
+
+  const validated = validateIdParam(projectId ?? "", mode);
+  if (validated instanceof Response) return validated;
+
+  let body: { conversationId?: string; messages?: IncomingMessage[] };
+  try {
+    body = (await req.json()) as typeof body;
+  } catch {
+    return jsonResponse(createApiError("Invalid JSON body", 400), { mode, status: 400 });
+  }
+
+  if (!body.conversationId || typeof body.conversationId !== "string") {
+    return jsonResponse(createApiError("conversationId is required", 400), { mode, status: 400 });
+  }
+
+  if (!Array.isArray(body.messages) || body.messages.length === 0) {
+    return jsonResponse(createApiError("messages is required and must be a non-empty array", 400), {
+      mode,
+      status: 400,
+    });
+  }
+
+  const conversationResult = getConversation(db, body.conversationId);
+  if ("error" in conversationResult) {
+    return jsonResponse(createApiError(conversationResult.error, conversationResult.status), {
+      mode,
+      status: conversationResult.status,
+    });
+  }
+
+  const conversation = conversationResult.conversation;
+  if (conversation.projectId !== validated.id) {
+    return jsonResponse(createApiError("会话不属于该项目", 403), { mode, status: 403 });
+  }
+
+  for (const msg of body.messages ?? []) {
+    createMessage(db, {
+      content: extractTextContent(msg),
+      conversationId: conversation.id,
+      role: (msg.role ?? "user") as "assistant" | "system" | "user",
+    });
+  }
+
+  updateConversationTimestamp(db, conversation.id);
+
+  try {
+    const result = agentStream({
+      db,
+      messages: body.messages,
+      modelDbId: conversation.modelId,
+    });
+
+    const stream = result.toUIMessageStreamResponse();
+
+    const saveReply = async () => {
+      try {
+        const fullContent = await result.text;
+        if (fullContent) {
+          createMessage(db, {
+            content: fullContent,
+            conversationId: conversation.id,
+            role: "assistant",
+          });
+          updateConversationTimestamp(db, conversation.id);
+        }
+      } catch {
+        // stream ended without content, nothing to persist
+      }
+    };
+
+    void saveReply();
+
+    return stream;
+  } catch (e: unknown) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return jsonResponse(createApiError(`AI 调用失败：${msg}`, 500), { mode, status: 500 });
+  }
+}

src/server/server.ts

@@ -156,6 +156,62 @@ export function startServer(options: StartServerOptions) {
           logger,
         ),
       },
+      "/api/projects/:id/chat": {
+        POST: withErrorHandler(
+          async (req) => {
+            const { handleSendChat } = await import("./routes/chat/send");
+            return handleSendChat(req, db, mode);
+          },
+          mode,
+          logger,
+        ),
+      },
+      "/api/projects/:id/conversations": {
+        GET: withErrorHandler(
+          async (req) => {
+            const { handleListConversations } = await import("./routes/chat/list");
+            return handleListConversations(req, db, mode);
+          },
+          mode,
+          logger,
+        ),
+        POST: withErrorHandler(
+          async (req) => {
+            const { handleCreateConversation } = await import("./routes/chat/create");
+            return handleCreateConversation(req, db, mode);
+          },
+          mode,
+          logger,
+        ),
+      },
+      "/api/projects/:id/conversations/:cid": {
+        DELETE: withErrorHandler(
+          async (req) => {
+            const { handleDeleteConversation } = await import("./routes/chat/delete");
+            return handleDeleteConversation(req, db, mode);
+          },
+          mode,
+          logger,
+        ),
+        GET: withErrorHandler(
+          async (req) => {
+            const { handleGetConversation } = await import("./routes/chat/get");
+            return handleGetConversation(req, db, mode);
+          },
+          mode,
+          logger,
+        ),
+      },
+      "/api/projects/:id/conversations/:cid/messages": {
+        GET: withErrorHandler(
+          async (req) => {
+            const { handleListMessages } = await import("./routes/chat/messages");
+            return handleListMessages(req, db, mode);
+          },
+          mode,
+          logger,
+        ),
+      },
       "/api/projects/:id/restore": {
         POST: withErrorHandler(
           async (req) => {