@zwbigi/ink-xy 0.1.2 → 0.1.4

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

@@ -0,0 +1,233 @@
+import type {
+  Message,
+  MessagePart,
+  PipelineStage,
+  SessionMessage,
+  SessionRuntime,
+  SessionSummary,
+  ToolExecution,
+} from "../../types";
+import { localizeKnownRuntimeMessage } from "../../../../lib/error-copy";
+
+const NULL_BOOK_KEY = "__null__";
+
+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: "生成封面",
+};
+
+export function bookKey(bookId: string | null | undefined): string {
+  return bookId ?? NULL_BOOK_KEY;
+}
+
+export function extractErrorMessage(error: string | { code?: string; message?: string }): string {
+  if (typeof error === "string") return localizeKnownRuntimeMessage(error);
+  return localizeKnownRuntimeMessage(error.message ?? "Unknown error");
+}
+
+export function resolveToolLabel(tool: string, agent?: string): string {
+  if (tool === "sub_agent" && agent) return AGENT_LABELS[agent] ?? agent;
+  return TOOL_LABELS[tool] ?? tool;
+}
+
+export function summarizeResult(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);
+}
+
+export function extractToolDetails(result: unknown): unknown {
+  if (!result || typeof result !== "object") return undefined;
+  return (result as Record<string, unknown>).details;
+}
+
+export function extractToolError(result: unknown): string {
+  if (typeof result === "string") return localizeKnownRuntimeMessage(result).slice(0, 500);
+  if (result && typeof result === "object") {
+    const record = result as Record<string, unknown>;
+    if (typeof record.content === "string") return localizeKnownRuntimeMessage(record.content).slice(0, 500);
+    if (record.content && Array.isArray(record.content)) {
+      const textPart = record.content.find((content: any) => content.type === "text");
+      if (textPart) return localizeKnownRuntimeMessage((textPart as any).text ?? "").slice(0, 500);
+    }
+  }
+  return localizeKnownRuntimeMessage(String(result)).slice(0, 500);
+}
+
+export function getOrCreateStream(
+  messages: ReadonlyArray<Message>,
+  streamTs: number,
+): [ReadonlyArray<Message>, Message] {
+  const last = messages[messages.length - 1];
+  if (last?.timestamp === streamTs && last.role === "assistant") {
+    return [messages, last];
+  }
+  const message: Message = { role: "assistant", content: "", timestamp: streamTs, parts: [] };
+  return [[...messages, message], message];
+}
+
+export function replaceLast(
+  messages: ReadonlyArray<Message>,
+  updated: Message,
+): ReadonlyArray<Message> {
+  return [...messages.slice(0, -1), updated];
+}
+
+export function findRunningToolPart(
+  parts: MessagePart[],
+): (MessagePart & { type: "tool" }) | undefined {
+  for (let i = parts.length - 1; i >= 0; i -= 1) {
+    const part = parts[i];
+    if (part.type === "tool" && part.execution.status === "running") {
+      return part as MessagePart & { type: "tool" };
+    }
+  }
+  return undefined;
+}
+
+export function deriveFlat(
+  parts: MessagePart[],
+): { content: string; thinking?: string; thinkingStreaming?: boolean; toolExecutions?: ToolExecution[] } {
+  let content = "";
+  let thinking = "";
+  let thinkingStreaming = false;
+  const toolExecutions: ToolExecution[] = [];
+
+  for (const part of parts) {
+    if (part.type === "thinking") {
+      if (thinking) thinking += "\n\n---\n\n";
+      thinking += part.content;
+      if (part.streaming) thinkingStreaming = true;
+      continue;
+    }
+
+    if (part.type === "text") {
+      content += part.content;
+      continue;
+    }
+
+    toolExecutions.push(part.execution);
+  }
+
+  return {
+    content,
+    ...(thinking ? { thinking } : {}),
+    ...(thinkingStreaming ? { thinkingStreaming: true } : {}),
+    ...(toolExecutions.length > 0 ? { toolExecutions } : {}),
+  };
+}
+
+export function createSessionRuntime(input: {
+  sessionId: string;
+  bookId: string | null;
+  title: string | null;
+  messages?: ReadonlyArray<Message>;
+  isDraft?: boolean;
+}): SessionRuntime {
+  return {
+    sessionId: input.sessionId,
+    bookId: input.bookId,
+    title: input.title,
+    messages: input.messages ?? [],
+    stream: null,
+    isStreaming: false,
+    lastError: null,
+    isDraft: input.isDraft ?? false,
+  };
+}
+
+export function deserializeMessages(
+  msgs: ReadonlyArray<SessionMessage>,
+): ReadonlyArray<Message> {
+  return msgs
+    .filter((message) => message.role === "user" || message.role === "assistant")
+    .map((message) => {
+      const toolExecutions = (message as any).toolExecutions as ToolExecution[] | undefined;
+      const parts: MessagePart[] = [];
+      if (message.thinking) parts.push({ type: "thinking", content: message.thinking, streaming: false });
+      if (toolExecutions) {
+        for (const execution of toolExecutions) {
+          parts.push({ type: "tool", execution });
+        }
+      }
+      if (message.content) parts.push({ type: "text", content: message.content });
+      return {
+        role: message.role as "user" | "assistant",
+        content: message.content,
+        thinking: message.thinking,
+        toolExecutions,
+        timestamp: message.timestamp,
+        parts: parts.length > 0 ? parts : undefined,
+      };
+    });
+}
+
+export function updateSession(
+  sessions: Record<string, SessionRuntime>,
+  sessionId: string,
+  updater: (session: SessionRuntime) => Partial<SessionRuntime>,
+): Record<string, SessionRuntime> {
+  const existing = sessions[sessionId];
+  if (!existing) return sessions;
+  return {
+    ...sessions,
+    [sessionId]: {
+      ...existing,
+      ...updater(existing),
+    },
+  };
+}
+
+export function upsertSessionSummary(
+  sessions: Record<string, SessionRuntime>,
+  summary: Pick<SessionSummary, "sessionId" | "bookId" | "title">,
+): Record<string, SessionRuntime> {
+  const existing = sessions[summary.sessionId];
+  return {
+    ...sessions,
+    [summary.sessionId]: existing
+      ? { ...existing, bookId: summary.bookId, title: summary.title }
+      : createSessionRuntime(summary),
+  };
+}
+
+export function mergeSessionIds(
+  existing: ReadonlyArray<string> | undefined,
+  incoming: ReadonlyArray<string>,
+): ReadonlyArray<string> {
+  if (!existing?.length) return [...incoming];
+  const seen = new Set(existing);
+  const appended = incoming.filter((id) => !seen.has(id));
+  if (appended.length === 0) return existing as string[];
+  return [...existing, ...appended];
+}
+
+export function sessionMatchesEvent(sessionId: string, data: unknown): boolean {
+  if (!data || typeof data !== "object") return false;
+  return (data as { sessionId?: unknown }).sessionId === sessionId;
+}

package/inkos/packages/studio/src/store/chat/slices/message/stream-events.ts

@@ -0,0 +1,272 @@
+import type { StateCreator } from "zustand";
+import type { ChatStore, MessageActions, PipelineStage } from "../../types";
+import { shouldRefreshSidebarForTool } from "../../message-policy";
+import {
+  deriveFlat,
+  extractToolDetails,
+  extractToolError,
+  findRunningToolPart,
+  getOrCreateStream,
+  replaceLast,
+  resolveToolLabel,
+  sessionMatchesEvent,
+  summarizeResult,
+  updateSession,
+} from "./runtime";
+
+type SliceSet = Parameters<StateCreator<ChatStore, [], [], MessageActions>>[0];
+type SliceGet = Parameters<StateCreator<ChatStore, [], [], MessageActions>>[1];
+
+interface AttachSessionStreamListenersInput {
+  sessionId: string;
+  streamTs: number;
+  streamEs: EventSource;
+  set: SliceSet;
+  get: SliceGet;
+}
+
+export function attachSessionStreamListeners({
+  sessionId,
+  streamTs,
+  streamEs,
+  set,
+  get,
+}: AttachSessionStreamListenersInput): void {
+  streamEs.addEventListener("thinking:start", (event: MessageEvent) => {
+    try {
+      const data = event.data ? JSON.parse(event.data) : null;
+      if (!sessionMatchesEvent(sessionId, data)) return;
+      set((state) => ({
+        sessions: updateSession(state.sessions, sessionId, (runtime) => {
+          const [messages, stream] = getOrCreateStream(runtime.messages, streamTs);
+          const parts = [...(stream.parts ?? []), { type: "thinking" as const, content: "", streaming: true }];
+          const flat = deriveFlat(parts);
+          return { messages: replaceLast(messages, { ...stream, ...flat, parts }) };
+        }),
+      }));
+    } catch {
+      // ignore
+    }
+  });
+
+  streamEs.addEventListener("thinking:delta", (event: MessageEvent) => {
+    try {
+      const data = event.data ? JSON.parse(event.data) : null;
+      if (!sessionMatchesEvent(sessionId, data) || !data?.text) return;
+      set((state) => ({
+        sessions: updateSession(state.sessions, sessionId, (runtime) => {
+          const [messages, stream] = getOrCreateStream(runtime.messages, streamTs);
+          const parts = [...(stream.parts ?? [])];
+          const last = parts[parts.length - 1];
+          if (last?.type === "thinking") {
+            parts[parts.length - 1] = { ...last, content: last.content + data.text };
+          }
+          const flat = deriveFlat(parts);
+          return { messages: replaceLast(messages, { ...stream, ...flat, parts }) };
+        }),
+      }));
+    } catch {
+      // ignore
+    }
+  });
+
+  streamEs.addEventListener("thinking:end", (event: MessageEvent) => {
+    try {
+      const data = event.data ? JSON.parse(event.data) : null;
+      if (!sessionMatchesEvent(sessionId, data)) return;
+      set((state) => ({
+        sessions: updateSession(state.sessions, sessionId, (runtime) => {
+          const [messages, stream] = getOrCreateStream(runtime.messages, streamTs);
+          const parts = [...(stream.parts ?? [])];
+          const last = parts[parts.length - 1];
+          if (last?.type === "thinking") {
+            parts[parts.length - 1] = { ...last, streaming: false };
+          }
+          const flat = deriveFlat(parts);
+          return { messages: replaceLast(messages, { ...stream, ...flat, parts }) };
+        }),
+      }));
+    } catch {
+      // ignore
+    }
+  });
+
+  streamEs.addEventListener("draft:delta", (event: MessageEvent) => {
+    try {
+      const data = event.data ? JSON.parse(event.data) : null;
+      if (!sessionMatchesEvent(sessionId, data) || !data?.text) return;
+      set((state) => ({
+        sessions: updateSession(state.sessions, sessionId, (runtime) => {
+          const [messages, stream] = getOrCreateStream(runtime.messages, streamTs);
+          const parts = [...(stream.parts ?? [])];
+          const last = parts[parts.length - 1];
+          if (last?.type === "text") {
+            parts[parts.length - 1] = { ...last, content: last.content + data.text };
+          } else {
+            parts.push({ type: "text", content: data.text });
+          }
+          const flat = deriveFlat(parts);
+          return { messages: replaceLast(messages, { ...stream, ...flat, parts }) };
+        }),
+      }));
+    } catch {
+      // ignore
+    }
+  });
+
+  streamEs.addEventListener("tool:start", (event: MessageEvent) => {
+    try {
+      const data = event.data ? JSON.parse(event.data) : null;
+      if (!sessionMatchesEvent(sessionId, data) || !data?.tool) return;
+      set((state) => ({
+        sessions: updateSession(state.sessions, sessionId, (runtime) => {
+          const [messages, stream] = getOrCreateStream(runtime.messages, streamTs);
+          const parts = [...(stream.parts ?? [])];
+
+          if (data.tool === "sub_agent") {
+            const last = parts[parts.length - 1];
+            if (last?.type === "text" && last.content) {
+              parts.pop();
+              const prev = parts[parts.length - 1];
+              if (prev?.type === "thinking") {
+                parts[parts.length - 1] = {
+                  ...prev,
+                  content: prev.content + (prev.content ? "\n\n" : "") + last.content,
+                };
+              } else {
+                parts.push({ type: "thinking", content: last.content, streaming: false });
+              }
+            }
+          }
+
+          const agent = data.tool === "sub_agent" ? (data.args?.agent as string | undefined) : undefined;
+          const stages: PipelineStage[] | undefined = Array.isArray(data.stages) && data.stages.length > 0
+            ? (data.stages as string[]).map((label) => ({ label, status: "pending" as const }))
+            : undefined;
+
+          parts.push({
+            type: "tool",
+            execution: {
+              id: data.id as string,
+              tool: data.tool as string,
+              agent,
+              label: resolveToolLabel(data.tool as string, agent),
+              status: "running",
+              args: data.args as Record<string, unknown> | undefined,
+              stages,
+              startedAt: Date.now(),
+            },
+          });
+
+          const flat = deriveFlat(parts);
+          return { messages: replaceLast(messages, { ...stream, ...flat, parts }) };
+        }),
+      }));
+    } catch {
+      // ignore
+    }
+  });
+
+  streamEs.addEventListener("tool:end", (event: MessageEvent) => {
+    try {
+      const data = event.data ? JSON.parse(event.data) : null;
+      if (!sessionMatchesEvent(sessionId, data) || !data?.tool) return;
+      set((state) => ({
+        sessions: updateSession(state.sessions, sessionId, (runtime) => {
+          const [messages, stream] = getOrCreateStream(runtime.messages, streamTs);
+          const parts = (stream.parts ?? []).map((part) => {
+            if (part.type !== "tool" || part.execution.id !== data.id) return part;
+            const execution = { ...part.execution };
+            execution.status = data.isError ? "error" : "completed";
+            execution.completedAt = Date.now();
+            execution.stages = execution.stages?.map((stage) =>
+              stage.status !== "completed"
+                ? { ...stage, status: "completed" as const, progress: undefined }
+                : stage,
+            );
+            if (data.isError) execution.error = extractToolError(data.result);
+            else execution.result = summarizeResult(data.result);
+            const details = data.details ?? extractToolDetails(data.result);
+            if (details !== undefined) execution.details = details;
+            return { type: "tool" as const, execution };
+          });
+          const flat = deriveFlat(parts);
+          return { messages: replaceLast(messages, { ...stream, ...flat, parts }) };
+        }),
+      }));
+
+      if (shouldRefreshSidebarForTool(data.tool as string)) {
+        get().bumpBookDataVersion();
+      }
+    } catch {
+      // ignore
+    }
+  });
+
+  streamEs.addEventListener("log", (event: MessageEvent) => {
+    try {
+      const data = event.data ? JSON.parse(event.data) : null;
+      if (!sessionMatchesEvent(sessionId, data)) return;
+      const message = data?.message as string | undefined;
+      if (!message) return;
+      set((state) => ({
+        sessions: updateSession(state.sessions, sessionId, (runtime) => {
+          const [messages, stream] = getOrCreateStream(runtime.messages, streamTs);
+          const runningTool = findRunningToolPart([...(stream.parts ?? [])]);
+          if (!runningTool) return {};
+          const parts = (stream.parts ?? []).map((part) => {
+            if (part.type !== "tool" || part.execution.id !== runningTool.execution.id) return part;
+            return {
+              type: "tool" as const,
+              execution: { ...part.execution, logs: [...(part.execution.logs ?? []), message] },
+            };
+          });
+          const flat = deriveFlat(parts);
+          return { messages: replaceLast(messages, { ...stream, ...flat, parts }) };
+        }),
+      }));
+    } catch {
+      // ignore
+    }
+  });
+
+  streamEs.addEventListener("llm:progress", (event: MessageEvent) => {
+    try {
+      const data = event.data ? JSON.parse(event.data) : null;
+      if (!sessionMatchesEvent(sessionId, data)) return;
+      set((state) => ({
+        sessions: updateSession(state.sessions, sessionId, (runtime) => {
+          const [messages, stream] = getOrCreateStream(runtime.messages, streamTs);
+          const runningTool = findRunningToolPart([...(stream.parts ?? [])]);
+          if (!runningTool?.execution.stages) return {};
+          const parts = (stream.parts ?? []).map((part) => {
+            if (part.type !== "tool" || part.execution.id !== runningTool.execution.id) return part;
+            return {
+              type: "tool" as const,
+              execution: {
+                ...part.execution,
+                stages: part.execution.stages?.map((stage) =>
+                  stage.status === "active"
+                    ? {
+                        ...stage,
+                        progress: {
+                          status: data.status,
+                          elapsedMs: data.elapsedMs,
+                          totalChars: data.totalChars,
+                          chineseChars: data.chineseChars,
+                        },
+                      }
+                    : stage,
+                ),
+              },
+            };
+          });
+          const flat = deriveFlat(parts);
+          return { messages: replaceLast(messages, { ...stream, ...flat, parts }) };
+        }),
+      }));
+    } catch {
+      // ignore
+    }
+  });
+}

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

@@ -0,0 +1,11 @@
+import { create } from "zustand";
+import type { ChatStore } from "./types";
+import { initialChatState } from "./initialState";
+import { createMessageSlice } from "./slices/message/action";
+import { createCreateSlice } from "./slices/create/action";
+
+export const useChatStore = create<ChatStore>()((...a) => ({
+  ...initialChatState,
+  ...createMessageSlice(...a),
+  ...createCreateSlice(...a),
+}));

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

@@ -0,0 +1,169 @@
+// -- Data types --
+
+export interface ToolCall {
+  readonly name: string;
+  readonly arguments: Record<string, unknown>;
+}
+
+export interface PipelineStage {
+  label: string;
+  status: "pending" | "active" | "completed";
+  progress?: {
+    status?: string;          // "thinking" | "streaming" | ...
+    elapsedMs: number;
+    totalChars: number;
+    chineseChars: number;
+  };
+}
+
+export interface ToolExecution {
+  id: string;
+  tool: string;
+  agent?: string;
+  label: string;
+  status: "running" | "processing" | "completed" | "error";
+  args?: Record<string, unknown>;
+  result?: string;
+  details?: unknown;
+  error?: string;
+  stages?: PipelineStage[];
+  logs?: string[];
+  startedAt: number;
+  completedAt?: number;
+}
+
+// -- Message parts (chronologically ordered for rendering) --
+
+export type MessagePart =
+  | { type: "thinking"; content: string; streaming: boolean }
+  | { type: "text"; content: string }
+  | { type: "tool"; execution: ToolExecution };
+
+export interface Message {
+  readonly role: "user" | "assistant";
+  readonly content: string;
+  readonly thinking?: string;
+  readonly thinkingStreaming?: boolean;
+  readonly timestamp: number;
+  readonly toolCall?: ToolCall;
+  readonly toolExecutions?: ToolExecution[];
+  readonly parts?: MessagePart[];              // chronological parts for interleaved rendering
+}
+
+export interface SessionMessage {
+  readonly role: "user" | "assistant" | "system";
+  readonly content: string;
+  readonly thinking?: string;
+  readonly toolExecutions?: ReadonlyArray<ToolExecution>;
+  readonly timestamp: number;
+}
+
+export interface SessionSummary {
+  readonly sessionId: string;
+  readonly bookId: string | null;
+  readonly title: string | null;
+  readonly messageCount: number;
+  readonly createdAt: number;
+  readonly updatedAt: number;
+}
+
+export interface AgentResponse {
+  readonly response?: string;
+  readonly error?: string | { code?: string; message?: string };
+  readonly details?: {
+    readonly draftRaw?: string;
+    readonly toolCall?: ToolCall;
+  };
+  readonly session?: {
+    readonly sessionId?: string;
+    readonly bookId?: string | null;
+    readonly title?: string | null;
+    readonly activeBookId?: string;
+    readonly creationDraft?: unknown;
+    readonly messages?: ReadonlyArray<SessionMessage>;
+  };
+  readonly request?: unknown;
+}
+
+export interface SessionResponse {
+  readonly session?: {
+    readonly sessionId?: string;
+    readonly bookId?: string | null;
+    readonly title?: string | null;
+    readonly activeBookId?: string;
+    readonly messages?: ReadonlyArray<SessionMessage>;
+  };
+  readonly activeBookId?: string;
+}
+
+// -- State interfaces --
+
+export interface BookSummary {
+  world: string;
+  protagonist: string;
+  cast: string;
+}
+
+export interface SessionRuntime {
+  readonly sessionId: string;
+  readonly bookId: string | null;
+  readonly title: string | null;
+  readonly messages: ReadonlyArray<Message>;
+  readonly stream: EventSource | null;
+  readonly isStreaming: boolean;
+  readonly lastError: string | null;
+  // 仅前端存在、尚未持久化到磁盘的草稿会话。发送第一条消息时才调 POST /sessions 把它落盘。
+  readonly isDraft: boolean;
+}
+
+export interface MessageState {
+  sessions: Record<string, SessionRuntime>;
+  sessionIdsByBook: Record<string, ReadonlyArray<string>>;
+  activeSessionId: string | null;
+  input: string;
+  selectedModel: string | null;
+  selectedService: string | null;
+}
+
+export interface CreateState {
+  bookDataVersion: number;
+  sidebarView: "panel" | "artifact";
+  artifactFile: string | null;         // foundation file name, e.g. "story_bible.md"
+  artifactChapter: number | null;      // chapter number, e.g. 1
+  bookSummary: BookSummary | null;
+}
+
+export type ChatState = MessageState & CreateState;
+
+// -- Action interfaces --
+
+export interface MessageActions {
+  activateSession: (sessionId: string | null) => void;
+  setInput: (text: string) => void;
+  addUserMessage: (sessionId: string, content: string) => void;
+  appendStreamChunk: (sessionId: string, text: string, streamTs: number) => void;
+  finalizeStream: (sessionId: string, streamTs: number, content: string, toolCall?: ToolCall) => void;
+  replaceStreamWithError: (sessionId: string, streamTs: number, errorMsg: string) => void;
+  addErrorMessage: (sessionId: string, errorMsg: string) => void;
+  loadSessionMessages: (sessionId: string, msgs: ReadonlyArray<SessionMessage>) => void;
+  loadSessionList: (bookId: string | null) => Promise<ReadonlyArray<SessionSummary>>;
+  createSession: (bookId: string | null) => Promise<string>;
+  createDraftSession: (bookId: string | null) => string;
+  renameSession: (sessionId: string, title: string) => Promise<void>;
+  deleteSession: (sessionId: string) => Promise<void>;
+  loadSessionDetail: (sessionId: string) => Promise<void>;
+  sendMessage: (sessionId: string, text: string, activeBookId?: string) => Promise<void>;
+  setSelectedModel: (model: string, service: string) => void;
+}
+
+export interface CreateActions {
+  bumpBookDataVersion: () => void;
+  openArtifact: (file: string) => void;
+  openChapterArtifact: (chapterNum: number) => void;
+  closeArtifact: () => void;
+  setBookSummary: (summary: BookSummary | null) => void;
+}
+
+// -- Composed store type --
+
+export type ChatStore = ChatState & MessageActions & CreateActions;

package/inkos/packages/studio/src/store/service/index.ts

@@ -0,0 +1,2 @@
+export { useServiceStore } from "./store";
+export type { EndpointGroup, ServiceStore, ServiceInfo, ModelInfo, ModelGroup, ModelPickerStatus } from "./types";