@zwbigi/ink-xy 0.1.2 → 0.1.4

package/inkos/packages/studio/src/store/chat/parts-builder.ts

@@ -0,0 +1,187 @@
+import type { MessagePart, ToolExecution, PipelineStage } from "./types";
+import { localizeKnownRuntimeMessage } from "../../lib/error-copy";
+
+// -- Event types for the builder --
+
+export type StreamEvent =
+  | { type: "thinking:start" }
+  | { type: "thinking:delta"; text: string }
+  | { type: "thinking:end" }
+  | { type: "draft:delta"; text: string }
+  | { type: "tool:start"; id: string; tool: string; agent?: string; stages?: string[] }
+  | { type: "tool:end"; id: string; isError?: boolean; result?: unknown; details?: unknown }
+  | { type: "log:stage"; stageName: string }
+  | { type: "llm:progress"; status: string; elapsedMs: number; totalChars: number; chineseChars: number };
+
+// -- Label helpers --
+
+const AGENT_LABELS: Record<string, string> = {
+  architect: "建书", writer: "写作", auditor: "审计",
+  reviser: "修订", exporter: "导出",
+};
+const TOOL_LABELS: Record<string, string> = {
+  read: "读取文件", edit: "编辑文件", grep: "搜索", ls: "列目录",
+  short_fiction_run: "短篇生产",
+  generate_cover: "生成封面",
+};
+
+function resolveToolLabel(tool: string, agent?: string): string {
+  if (tool === "sub_agent" && agent) return AGENT_LABELS[agent] ?? agent;
+  return TOOL_LABELS[tool] ?? tool;
+}
+
+function summarizeToolResult(result: unknown): string {
+  if (typeof result === "string") return result.slice(0, 2000);
+  if (result && typeof result === "object") {
+    const record = result as Record<string, unknown>;
+    if (typeof record.content === "string") return record.content.slice(0, 2000);
+    if (Array.isArray(record.content)) {
+      const text = record.content
+        .map((part) => {
+          const item = part as { type?: unknown; text?: unknown };
+          return item.type === "text" && typeof item.text === "string" ? item.text : "";
+        })
+        .filter(Boolean)
+        .join("\n");
+      if (text.trim()) return text.slice(0, 2000);
+    }
+  }
+  return String(result ?? "").slice(0, 2000);
+}
+
+// -- Builder --
+
+export function buildPartsFromEvents(events: StreamEvent[]): MessagePart[] {
+  const parts: MessagePart[] = [];
+
+  /** Find the last tool part that is still "running". */
+  function findRunningTool(): ToolExecution | undefined {
+    for (let i = parts.length - 1; i >= 0; i--) {
+      const p = parts[i];
+      if (p.type === "tool" && p.execution.status === "running") return p.execution;
+    }
+    return undefined;
+  }
+
+  for (const event of events) {
+    switch (event.type) {
+      case "thinking:start": {
+        parts.push({ type: "thinking", content: "", streaming: true });
+        break;
+      }
+
+      case "thinking:delta": {
+        // Append to last thinking part
+        const last = parts[parts.length - 1];
+        if (last?.type === "thinking") {
+          last.content += event.text;
+        }
+        break;
+      }
+
+      case "thinking:end": {
+        const last = parts[parts.length - 1];
+        if (last?.type === "thinking") {
+          last.streaming = false;
+        }
+        break;
+      }
+
+      case "draft:delta": {
+        // Append to last text part, or create a new one
+        const last = parts[parts.length - 1];
+        if (last?.type === "text") {
+          last.content += event.text;
+        } else {
+          parts.push({ type: "text", content: event.text });
+        }
+        break;
+      }
+
+      case "tool:start": {
+        // For pipeline operations (sub_agent), move trailing text to thinking
+        // (it's the agent's reasoning before calling the tool, not user-facing content).
+        // For utility tools (read/grep/edit/ls), keep text as-is.
+        if (event.tool === "sub_agent") {
+          const last = parts[parts.length - 1];
+          if (last?.type === "text" && last.content) {
+            parts.pop();
+            const prevPart = parts[parts.length - 1];
+            if (prevPart?.type === "thinking") {
+              prevPart.content += (prevPart.content ? "\n\n" : "") + last.content;
+            } else {
+              parts.push({ type: "thinking", content: last.content, streaming: false });
+            }
+          }
+        }
+
+        const stages: PipelineStage[] | undefined = event.stages?.length
+          ? event.stages.map((label) => ({ label, status: "pending" as const }))
+          : undefined;
+
+        const exec: ToolExecution = {
+          id: event.id,
+          tool: event.tool,
+          agent: event.agent,
+          label: resolveToolLabel(event.tool, event.agent),
+          status: "running",
+          stages,
+          startedAt: Date.now(),
+        };
+
+        parts.push({ type: "tool", execution: exec });
+        break;
+      }
+
+      case "tool:end": {
+        // Find matching tool part by id
+        for (const p of parts) {
+          if (p.type === "tool" && p.execution.id === event.id) {
+            const exec = p.execution;
+            exec.status = event.isError ? "error" : "completed";
+            exec.completedAt = Date.now();
+            if (event.isError) exec.error = localizeKnownRuntimeMessage(summarizeToolResult(event.result));
+            else exec.result = summarizeToolResult(event.result);
+            if (event.details !== undefined) exec.details = event.details;
+            // Mark all remaining stages as completed
+            exec.stages = exec.stages?.map((s) =>
+              s.status !== "completed" ? { ...s, status: "completed" as const, progress: undefined } : s
+            );
+            break;
+          }
+        }
+        break;
+      }
+
+      case "log:stage": {
+        const exec = findRunningTool();
+        if (!exec?.stages) break;
+        let found = false;
+        exec.stages = exec.stages.map((stage) => {
+          if (stage.label === event.stageName) {
+            found = true;
+            return { ...stage, status: "active" as const };
+          }
+          if (!found && stage.status === "active") {
+            return { ...stage, status: "completed" as const, progress: undefined };
+          }
+          return stage;
+        });
+        break;
+      }
+
+      case "llm:progress": {
+        const exec = findRunningTool();
+        if (!exec?.stages) break;
+        exec.stages = exec.stages.map((stage) =>
+          stage.status === "active"
+            ? { ...stage, progress: { status: event.status, elapsedMs: event.elapsedMs, totalChars: event.totalChars, chineseChars: event.chineseChars } }
+            : stage
+        );
+        break;
+      }
+    }
+  }
+
+  return parts;
+}

package/inkos/packages/studio/src/store/chat/selectors.ts

@@ -0,0 +1,13 @@
+import type { ChatState } from "./types";
+
+const EMPTY_MESSAGES: readonly [] = [];
+
+export const chatSelectors = {
+  activeSession: (s: ChatState) => (s.activeSessionId ? s.sessions[s.activeSessionId] ?? null : null),
+  activeMessages: (s: ChatState) =>
+    (s.activeSessionId ? s.sessions[s.activeSessionId]?.messages : undefined) ?? EMPTY_MESSAGES,
+  isActiveSessionStreaming: (s: ChatState) => Boolean(s.activeSessionId && s.sessions[s.activeSessionId]?.isStreaming),
+  isEmpty: (s: ChatState) =>
+    ((s.activeSessionId ? s.sessions[s.activeSessionId]?.messages.length : 0) ?? 0) === 0
+    && !Boolean(s.activeSessionId && s.sessions[s.activeSessionId]?.isStreaming),
+};

package/inkos/packages/studio/src/store/chat/slices/create/action.ts

@@ -0,0 +1,10 @@
+import type { StateCreator } from "zustand";
+import type { ChatStore, CreateActions } from "../../types";
+
+export const createCreateSlice: StateCreator<ChatStore, [], [], CreateActions> = (set) => ({
+  bumpBookDataVersion: () => set((s) => ({ bookDataVersion: s.bookDataVersion + 1 })),
+  openArtifact: (file) => set({ sidebarView: "artifact", artifactFile: file, artifactChapter: null }),
+  openChapterArtifact: (chapterNum) => set({ sidebarView: "artifact", artifactFile: null, artifactChapter: chapterNum }),
+  closeArtifact: () => set({ sidebarView: "panel", artifactFile: null, artifactChapter: null }),
+  setBookSummary: (summary) => set({ bookSummary: summary }),
+});

package/inkos/packages/studio/src/store/chat/slices/create/initialState.ts

@@ -0,0 +1,9 @@
+import type { CreateState } from "../../types";
+
+export const initialCreateState: CreateState = {
+  bookDataVersion: 0,
+  sidebarView: "panel",
+  artifactFile: null,
+  artifactChapter: null,
+  bookSummary: null,
+};

package/inkos/packages/studio/src/store/chat/slices/message/action.ts

@@ -0,0 +1,417 @@
+import type { StateCreator } from "zustand";
+import type {
+  AgentResponse,
+  ChatStore,
+  MessageActions,
+  SessionResponse,
+  SessionSummary,
+} from "../../types";
+import { fetchJson } from "../../../../hooks/use-api";
+import { attachSessionStreamListeners } from "./stream-events";
+import {
+  bookKey,
+  createSessionRuntime,
+  deserializeMessages,
+  extractErrorMessage,
+  mergeSessionIds,
+  updateSession,
+  upsertSessionSummary,
+} from "./runtime";
+
+export const createMessageSlice: StateCreator<ChatStore, [], [], MessageActions> = (set, get) => ({
+  activateSession: (sessionId) =>
+    set({ activeSessionId: sessionId }),
+
+  setInput: (text) => set({ input: text }),
+
+  addUserMessage: (sessionId, content) =>
+    set((state) => ({
+      sessions: updateSession(state.sessions, sessionId, (session) => ({
+        messages: [...session.messages, { role: "user", content, timestamp: Date.now() }],
+        lastError: null,
+      })),
+    })),
+
+  appendStreamChunk: (sessionId, text, streamTs) =>
+    set((state) => ({
+      sessions: updateSession(state.sessions, sessionId, (session) => {
+        const last = session.messages[session.messages.length - 1];
+        if (last?.timestamp === streamTs && last.role === "assistant") {
+          return {
+            messages: [...session.messages.slice(0, -1), { ...last, content: last.content + text }],
+          };
+        }
+        return {
+          messages: [...session.messages, { role: "assistant", content: text, timestamp: streamTs }],
+        };
+      }),
+    })),
+
+  finalizeStream: (sessionId, streamTs, content, toolCall) =>
+    set((state) => ({
+      sessions: updateSession(state.sessions, sessionId, (session) => ({
+        messages: session.messages.map((message) => {
+          if (message.timestamp !== streamTs || message.role !== "assistant") return message;
+          const parts = [...(message.parts ?? [])];
+          const lastPart = parts[parts.length - 1];
+          if (lastPart?.type === "text") {
+            parts[parts.length - 1] = { ...lastPart, content };
+          } else if (content) {
+            parts.push({ type: "text", content });
+          }
+          return { ...message, content, toolCall, parts };
+        }),
+      })),
+    })),
+
+  replaceStreamWithError: (sessionId, streamTs, errorMsg) =>
+    set((state) => ({
+      sessions: updateSession(state.sessions, sessionId, (session) => ({
+        messages: [
+          ...session.messages.filter(
+            (message) => !(message.timestamp === streamTs && message.role === "assistant"),
+          ),
+          { role: "assistant", content: `\u2717 ${errorMsg}`, timestamp: Date.now() },
+        ],
+        isStreaming: false,
+        lastError: errorMsg,
+        stream: null,
+      })),
+    })),
+
+  addErrorMessage: (sessionId, errorMsg) =>
+    set((state) => ({
+      sessions: updateSession(state.sessions, sessionId, (session) => ({
+        messages: [...session.messages, { role: "assistant", content: `\u2717 ${errorMsg}`, timestamp: Date.now() }],
+        lastError: errorMsg,
+      })),
+    })),
+
+  loadSessionMessages: (sessionId, msgs) =>
+    set((state) => ({
+      sessions: updateSession(state.sessions, sessionId, (session) => {
+        if (session.messages.length > 0) return {};
+        return { messages: deserializeMessages(msgs) };
+      }),
+    })),
+
+  setSelectedModel: (model, service) => set({ selectedModel: model, selectedService: service }),
+
+  loadSessionList: async (bookId) => {
+    const query = bookId === null ? "null" : encodeURIComponent(bookId);
+    try {
+      const data = await fetchJson<{ sessions: ReadonlyArray<SessionSummary> }>(`/sessions?bookId=${query}`);
+      set((state) => {
+        let sessions = state.sessions;
+        for (const summary of data.sessions) {
+          sessions = upsertSessionSummary(sessions, summary);
+        }
+        return {
+          sessions,
+          sessionIdsByBook: {
+            ...state.sessionIdsByBook,
+            [bookKey(bookId)]: data.sessions.map((session) => session.sessionId),
+          },
+        };
+      });
+      return data.sessions;
+    } catch {
+      return [];
+    }
+  },
+
+  createSession: async (bookId) => {
+    const data = await fetchJson<SessionResponse>("/sessions", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ bookId }),
+    });
+    const sessionId = data.session?.sessionId;
+    if (!sessionId) {
+      throw new Error("Failed to create session");
+    }
+
+    set((state) => {
+      const runtime = createSessionRuntime({
+        sessionId,
+        bookId: data.session?.bookId ?? bookId ?? null,
+        title: data.session?.title ?? null,
+      });
+      return {
+        sessions: {
+          ...state.sessions,
+          [sessionId]: runtime,
+        },
+        sessionIdsByBook: {
+          ...state.sessionIdsByBook,
+          [bookKey(runtime.bookId)]: mergeSessionIds(
+            state.sessionIdsByBook[bookKey(runtime.bookId)],
+            [sessionId],
+          ),
+        },
+        activeSessionId: sessionId,
+      };
+    });
+
+    return sessionId;
+  },
+
+  createDraftSession: (bookId) => {
+    // 前端生成 sessionId（与后端 createBookSession 同格式），暂不持久化到磁盘，
+    // 也暂不写入 sessionIdsByBook——侧边栏看不到这条 draft。
+    // 发送第一条消息时 sendMessage 会调 POST /sessions { sessionId, bookId } 落盘
+    // 并把 id 追加进 sessionIdsByBook，那一刻侧边栏才出现该会话（带着 title）。
+    const sessionId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    set((state) => {
+      const runtime = createSessionRuntime({
+        sessionId,
+        bookId,
+        title: null,
+        isDraft: true,
+      });
+      return {
+        sessions: {
+          ...state.sessions,
+          [sessionId]: runtime,
+        },
+        activeSessionId: sessionId,
+      };
+    });
+    return sessionId;
+  },
+
+  renameSession: async (sessionId, title) => {
+    const previous = get().sessions[sessionId]?.title ?? null;
+    set((state) => ({
+      sessions: updateSession(state.sessions, sessionId, () => ({ title })),
+    }));
+
+    try {
+      await fetchJson(`/sessions/${sessionId}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ title }),
+      });
+    } catch {
+      set((state) => ({
+        sessions: updateSession(state.sessions, sessionId, () => ({ title: previous })),
+      }));
+    }
+  },
+
+  deleteSession: async (sessionId) => {
+    const session = get().sessions[sessionId];
+    session?.stream?.close();
+    // 草稿会话还没写到磁盘，跳过 DELETE 请求避免后端返回 404
+    if (session && !session.isDraft) {
+      try {
+        await fetchJson(`/sessions/${sessionId}`, { method: "DELETE" });
+      } catch {
+        // ignore
+      }
+    }
+
+    set((state) => {
+      const { [sessionId]: deleted, ...rest } = state.sessions;
+      const sessionIdsByBook = Object.fromEntries(
+        Object.entries(state.sessionIdsByBook).map(([key, ids]) => [
+          key,
+          ids.filter((id) => id !== sessionId),
+        ]),
+      );
+
+      let activeSessionId = state.activeSessionId;
+      if (activeSessionId === sessionId) {
+        const fallbackKey = bookKey(session?.bookId ?? null);
+        activeSessionId = sessionIdsByBook[fallbackKey]?.[0] ?? null;
+      }
+
+      return {
+        sessions: rest,
+        sessionIdsByBook,
+        activeSessionId,
+      };
+    });
+  },
+
+  loadSessionDetail: async (sessionId) => {
+    // 草稿会话：磁盘上还没有文件，直接跳过远端拉取。
+    // 本地已有消息：不拉取远端，避免流式中或未持久化的消息被覆盖。
+    const existing = get().sessions[sessionId];
+    if (existing?.isDraft) return;
+    if (existing && existing.messages.length > 0) return;
+
+    try {
+      const data = await fetchJson<SessionResponse>(`/sessions/${sessionId}`);
+      const detail = data.session;
+      if (!detail?.sessionId) return;
+      const detailSessionId = detail.sessionId;
+      const messages = detail.messages ? deserializeMessages(detail.messages) : [];
+
+      set((state) => {
+        const runtime = state.sessions[detailSessionId];
+        // set 执行到这里可能已有本地消息写入（比如并发 sendMessage），再查一次。
+        if (runtime && runtime.messages.length > 0) return {};
+        const nextBookId = detail.bookId ?? runtime?.bookId ?? null;
+        return {
+          sessions: {
+            ...state.sessions,
+            [detailSessionId]: {
+              ...(runtime ?? createSessionRuntime({
+                sessionId: detailSessionId,
+                bookId: nextBookId,
+                title: detail.title ?? null,
+              })),
+              bookId: nextBookId,
+              title: detail.title ?? runtime?.title ?? null,
+              messages,
+            },
+          },
+          sessionIdsByBook: {
+            ...state.sessionIdsByBook,
+            [bookKey(nextBookId)]: mergeSessionIds(
+              state.sessionIdsByBook[bookKey(nextBookId)],
+              [detailSessionId],
+            ),
+          },
+        };
+      });
+    } catch {
+      // ignore
+    }
+  },
+
+  sendMessage: async (sessionId, text, activeBookId) => {
+    const trimmed = text.trim();
+    const session = get().sessions[sessionId];
+    if (!trimmed || !session || session.isStreaming) return;
+
+    if (!get().selectedModel) {
+      get().addUserMessage(sessionId, trimmed);
+      get().addErrorMessage(sessionId, "请先选择一个模型");
+      return;
+    }
+
+    // 草稿会话：第一条消息发送时才真正把 session 文件写到磁盘。
+    // 后端 POST /sessions 支持接受客户端传入的 sessionId，所以 id 保持一致，
+    // 前端 store 里的 runtime 不用 remount，只需要把 isDraft 翻成 false。
+    if (session.isDraft) {
+      try {
+        await fetchJson<SessionResponse>("/sessions", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ sessionId, bookId: session.bookId }),
+        });
+        // 落盘成功：把 isDraft 翻成 false，同时把 sessionId 追加进 sessionIdsByBook
+        // 让侧边栏现在才看到这条会话。
+        set((state) => ({
+          sessions: updateSession(state.sessions, sessionId, () => ({ isDraft: false })),
+          sessionIdsByBook: {
+            ...state.sessionIdsByBook,
+            [bookKey(session.bookId)]: mergeSessionIds(
+              state.sessionIdsByBook[bookKey(session.bookId)],
+              [sessionId],
+            ),
+          },
+        }));
+      } catch (err) {
+        get().addErrorMessage(sessionId, err instanceof Error ? err.message : String(err));
+        return;
+      }
+    }
+
+    const instruction = trimmed;
+    const streamTs = Date.now() + 1;
+
+    set((state) => ({
+      input: "",
+      activeSessionId: sessionId,
+      sessions: updateSession(state.sessions, sessionId, () => ({
+        isStreaming: true,
+        lastError: null,
+      })),
+    }));
+
+    get().addUserMessage(sessionId, trimmed);
+    session.stream?.close();
+    const streamEs = new EventSource("/api/v1/events");
+    set((state) => ({
+      sessions: updateSession(state.sessions, sessionId, () => ({ stream: streamEs })),
+    }));
+    attachSessionStreamListeners({ sessionId, streamTs, streamEs, set, get });
+
+    try {
+      const data = await fetchJson<AgentResponse>("/agent", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          instruction,
+          activeBookId,
+          sessionId,
+          model: get().selectedModel ?? undefined,
+          service: get().selectedService ?? undefined,
+        }),
+      });
+
+      streamEs.close();
+
+      const finalContent = data.details?.draftRaw || data.response || "";
+      const toolCall = data.details?.toolCall ?? undefined;
+      const hasStream = Boolean(
+        get().sessions[sessionId]?.messages.some((message) => message.timestamp === streamTs),
+      );
+
+      if (data.error) {
+        const errorMessage = extractErrorMessage(data.error);
+        if (hasStream) {
+          get().replaceStreamWithError(sessionId, streamTs, errorMessage);
+        } else {
+          get().addErrorMessage(sessionId, errorMessage);
+        }
+      } else if (finalContent) {
+        if (hasStream) {
+          get().finalizeStream(sessionId, streamTs, finalContent, toolCall);
+        } else {
+          set((state) => ({
+            sessions: updateSession(state.sessions, sessionId, (runtime) => ({
+              messages: [
+                ...runtime.messages,
+                {
+                  role: "assistant",
+                  content: finalContent,
+                  timestamp: Date.now(),
+                  toolCall,
+                },
+              ],
+            })),
+          }));
+        }
+      } else {
+        const emptyMessage = "模型未返回文本内容。请检查协议类型（chat/responses）、流式开关或上游服务兼容性。";
+        if (hasStream) {
+          get().replaceStreamWithError(sessionId, streamTs, emptyMessage);
+        } else {
+          get().addErrorMessage(sessionId, emptyMessage);
+        }
+      }
+    } catch (error) {
+      streamEs.close();
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const hasStream = Boolean(
+        get().sessions[sessionId]?.messages.some((message) => message.timestamp === streamTs),
+      );
+      if (hasStream) {
+        get().replaceStreamWithError(sessionId, streamTs, errorMessage);
+      } else {
+        get().addErrorMessage(sessionId, errorMessage);
+      }
+    } finally {
+      set((state) => ({
+        sessions: updateSession(state.sessions, sessionId, (runtime) => ({
+          isStreaming: false,
+          stream: runtime.stream === streamEs ? null : runtime.stream,
+        })),
+      }));
+    }
+  },
+});

package/inkos/packages/studio/src/store/chat/slices/message/initialState.ts

@@ -0,0 +1,10 @@
+import type { MessageState } from "../../types";
+
+export const initialMessageState: MessageState = {
+  sessions: {},
+  sessionIdsByBook: {},
+  activeSessionId: null,
+  input: "",
+  selectedModel: null,
+  selectedService: null,
+};

package/inkos/packages/studio/src/store/chat/slices/message/runtime.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+import { extractErrorMessage, extractToolError } from "./runtime";
+
+describe("chat runtime error copy", () => {
+  it("localizes known assistant errors", () => {
+    expect(extractErrorMessage({
+      message: "Latest chapter 1 is state-degraded. Repair state or rewrite that chapter before continuing.",
+    })).toBe("最新第 1 章处于状态降级（state-degraded）。继续写下一章前，请先修复状态，或重写这一章。");
+  });
+
+  it("localizes known tool errors", () => {
+    expect(extractToolError({
+      content: [
+        {
+          type: "text",
+          text: "Latest chapter 2 is state-degraded. Repair state or rewrite that chapter before continuing.",
+        },
+      ],
+    })).toBe("最新第 2 章处于状态降级（state-degraded）。继续写下一章前，请先修复状态，或重写这一章。");
+  });
+});