chatlab-cli 0.25.0 → 0.26.0

package/dist/{chunk-FSHVDWI2.mjs → chunk-SJIOPSMM.mjs}

@@ -7,33 +7,38 @@ const __dirname = __pathDirname(__filename);
 import {
   importData,
   parseFile
-} from "./chunk-TCPXAX3F.mjs";
+} from "./chunk-WXC6RZCX.mjs";
 import {
   analyzeIncrementalImport,
   analyzeNewImport,
   incrementalImport,
   streamImport
-} from "./chunk-GNT5G74Z.mjs";
+} from "./chunk-TC74HESZ.mjs";
 import {
-  AGENT_TOOL_REGISTRY,
-  CoreDataProvider
-} from "./chunk-E65ABM3C.mjs";
+  assertCliDataDirCompatible
+} from "./chunk-UB4XBM4R.mjs";
 import {
   getVersion
 } from "./chunk-5ADKYYNA.mjs";
 import {
-  AIConversationManager,
+  closeServerAiLogger,
+  createCliRunAgentStream,
+  initServerAiLogger
+} from "./chunk-ILGSSXOG.mjs";
+import {
+  AGENT_TOOL_REGISTRY,
+  CoreDataProvider
+} from "./chunk-IRZRIHIT.mjs";
+import {
+  AIChatManager,
   ALL_MIGRATIONS,
-  AgentEventHandler,
-  AiLogger,
   AssistantManager,
   BUILTIN_MODELS,
   BUILTIN_PROVIDERS,
   BUILTIN_TOOL_CATALOG,
-  CHART_CAPABILITY_CORE_TOOLS,
   CustomModelStore,
   CustomProviderStore,
-  DEFAULT_MAX_TOOL_ROUNDS,
+  DataDirCompatibilityError,
   DatabaseManager,
   LLMConfigStore,
   MergeSessionCache,
@@ -41,24 +46,14 @@ import {
   NodePathProvider,
   POS_TAG_DEFINITIONS,
   PreferencesManager,
-  SkillManager,
   SkillManagerCore,
   TempDbWriter,
   applyPendingNodeDataDirMigrationIfNeeded,
-  applyPreprocessingPipeline,
-  batchSegmentWithFrequency,
   buildMergedOutput,
   buildPiModel,
-  buildSkillMenuWithBuiltinChart,
-  buildSystemPrompt,
-  checkAndCompress,
   checkConflictsFromSources,
   computeWordFrequency,
   countMessagesTokens,
-  createActivateSkillTool,
-  createAiTranslate,
-  createChartSchemaGateState,
-  createCompressionLlmAdapter,
   createDatabaseManagerAdapter,
   createJiebaNlpProvider,
   createNodeDataDirSwitch,
@@ -74,13 +69,9 @@ import {
   fetchRemoteModels,
   filterMessagesWithContext,
   findEntryFileInDirectory,
-  formatAIError,
-  getAllowedBuiltinToolsForChartAutoSkill,
   getAvailableYears,
   getBuiltinModelsByProvider,
   getCatchphraseAnalysis,
-  getChartCapabilitySkill,
-  getChatOverview,
   getClusterGraph,
   getDailyActivity,
   getDefaultNodeUserDataDir,
@@ -104,25 +95,19 @@ import {
   getSessionInfo,
   getSessionMeta,
   getSessionOverview,
-  getSkillConfigWithBuiltinChart,
   getSupportedFormats,
   getTimeRange,
   getWeekdayActivity,
   getYearlyActivity,
   hasPendingElectronDataWarning,
   initNlpDir,
-  initTokenizer,
   isDictDownloaded,
   isNewerStableVersion,
   loadConfig,
   member_service_exports,
   mergeRulesForLocale,
-  openBetterSqliteDatabase,
-  parseAssistantFile,
   queryMessages,
   resolveApiKey,
-  resolveChartRuntimeForRequest,
-  runAgentCore,
   runSimpleLlmStream,
   scanMultiChatFile,
   segmentText,
@@ -134,16 +119,15 @@ import {
   summary_service_exports,
   validateApiKey,
   verifyCliDataPath,
-  wrapWithChartSchemaGate,
   writeAuthProfile,
   writeConfigField
-} from "./chunk-4OMV4VNH.mjs";
+} from "./chunk-QY67NN65.mjs";
 import {
   resolveCliPath
 } from "./chunk-FJ35V3TE.mjs";
 
 // src/http/index.ts
-import * as fs11 from "fs";
+import * as fs9 from "fs";
 import * as crypto4 from "crypto";
 
 // src/http/server.ts
@@ -159,6 +143,7 @@ var HTTP_STATUS = {
   ["SQL_EXECUTION_ERROR" /* SQL_EXECUTION_ERROR */]: 400,
   ["EXPORT_TOO_LARGE" /* EXPORT_TOO_LARGE */]: 400,
   ["BODY_TOO_LARGE" /* BODY_TOO_LARGE */]: 413,
+  ["DATA_DIR_INCOMPATIBLE" /* DATA_DIR_INCOMPATIBLE */]: 409,
   ["SERVER_ERROR" /* SERVER_ERROR */]: 500
 };
 var ApiError = class extends Error {
@@ -189,6 +174,14 @@ function exportTooLarge(count, limit) {
 function serverError(message = "Internal server error") {
   return new ApiError("SERVER_ERROR" /* SERVER_ERROR */, message);
 }
+function dataDirIncompatible(message) {
+  return new ApiError("DATA_DIR_INCOMPATIBLE" /* DATA_DIR_INCOMPATIBLE */, message);
+}
+function apiErrorFromUnknown(error) {
+  if (error instanceof ApiError) return error;
+  if (error instanceof DataDirCompatibilityError) return dataDirIncompatible(error.message);
+  return null;
+}
 function successResponse(data, meta) {
   return {
     success: true,
@@ -799,7 +792,7 @@ function registerExportRoutes(server2, ctx) {
       timeFilter: body.timeFilter,
       senderIds: body.senderIds,
       contextSize: body.contextSize,
-      chatSessionIds: body.chatSessionIds
+      segmentIds: body.segmentIds
     });
     if (!result.success) {
       return reply.code(500).send({ error: result.error });
@@ -1181,10 +1174,10 @@ function registerAiFilterRoutes(server2, ctx) {
     return filterMessagesWithContext(db, { keywords, timeFilter, senderIds, contextSize, page, pageSize });
   });
   server2.post("/_web/ai/multiple-sessions-messages", async (request, reply) => {
-    const { sessionId, chatSessionIds, page, pageSize } = request.body;
+    const { sessionId, segmentIds, page, pageSize } = request.body;
     const db = ctx.dbManager.open(sessionId);
     if (!db) return reply.code(404).send({ error: `Session not found: ${sessionId}` });
-    return getMultipleSessionsMessages(db, chatSessionIds, page, pageSize);
+    return getMultipleSessionsMessages(db, segmentIds, page, pageSize);
   });
 }
 
@@ -1263,31 +1256,31 @@ function registerAiToolRoutes(server2, ctx) {
   });
 }
 
-// ../../packages/http-routes/src/routes/web/ai-conversations.ts
-function registerAiConversationRoutes(server2, ctx) {
-  const cm = ctx.conversationManager;
+// ../../packages/http-routes/src/routes/web/ai-chats.ts
+function registerAiChatRoutes(server2, ctx) {
+  const cm = ctx.aiChatManager;
   if (!cm) return;
-  server2.post("/_web/ai/conversations", async (request) => {
+  server2.post("/_web/ai/chats", async (request) => {
     const { sessionId, title, assistantId } = request.body;
-    return cm.createConversation(sessionId, title, assistantId);
+    return cm.createAIChat(sessionId, title, assistantId);
   });
-  server2.get("/_web/ai/conversations", async (request) => {
+  server2.get("/_web/ai/chats", async (request) => {
     const { sessionId } = request.query;
     if (!sessionId) return [];
-    return cm.getConversations(sessionId);
+    return cm.getAIChats(sessionId);
   });
-  server2.get("/_web/ai/conversations/:id", async (request, reply) => {
-    const conv = cm.getConversation(request.params.id);
-    if (!conv) return reply.code(404).send({ error: "Conversation not found" });
+  server2.get("/_web/ai/chats/:id", async (request, reply) => {
+    const conv = cm.getAIChat(request.params.id);
+    if (!conv) return reply.code(404).send({ error: "AI chat not found" });
     return conv;
   });
-  server2.put("/_web/ai/conversations/:id/title", async (request) => {
-    return cm.updateConversationTitle(request.params.id, request.body.title);
+  server2.put("/_web/ai/chats/:id/title", async (request) => {
+    return cm.updateAIChatTitle(request.params.id, request.body.title);
   });
-  server2.delete("/_web/ai/conversations/:id", async (request) => {
-    return cm.deleteConversation(request.params.id);
+  server2.delete("/_web/ai/chats/:id", async (request) => {
+    return cm.deleteAIChat(request.params.id);
   });
-  server2.post("/_web/ai/conversations/:id/messages", async (request) => {
+  server2.post("/_web/ai/chats/:id/messages", async (request) => {
     const { role, content, dataKeywords, dataMessageCount, contentBlocks, tokenUsage } = request.body;
     return cm.addMessage(
       request.params.id,
@@ -1299,23 +1292,23 @@ function registerAiConversationRoutes(server2, ctx) {
       tokenUsage
     );
   });
-  server2.get("/_web/ai/conversations/:id/messages", async (request) => {
+  server2.get("/_web/ai/chats/:id/messages", async (request) => {
     return cm.getMessages(request.params.id);
   });
-  server2.post("/_web/ai/conversations/:id/messages/:messageId/delete-from", async (request, reply) => {
+  server2.post("/_web/ai/chats/:id/messages/:messageId/delete-from", async (request, reply) => {
     const { id, messageId } = request.params;
     if (!id || typeof id !== "string" || !messageId || typeof messageId !== "string") {
-      return reply.code(400).send({ error: "conversation id and messageId are required" });
+      return reply.code(400).send({ error: "aiChatId and messageId are required" });
     }
     cm.deleteMessagesFrom(id, messageId);
     return { success: true };
   });
-  server2.post("/_web/ai/conversations/:id/fork", async (request, reply) => {
+  server2.post("/_web/ai/chats/:id/fork", async (request, reply) => {
     const { upToMessageId, title } = request.body;
     if (!upToMessageId || typeof upToMessageId !== "string") {
       return reply.code(400).send({ error: "upToMessageId is required" });
     }
-    return cm.forkConversation(request.params.id, upToMessageId, title);
+    return cm.forkAIChat(request.params.id, upToMessageId, title);
   });
   server2.put("/_web/ai/messages/:messageId/content", async (request, reply) => {
     const { content } = request.body;
@@ -1325,23 +1318,23 @@ function registerAiConversationRoutes(server2, ctx) {
     cm.updateMessageContent(request.params.messageId, content);
     return { success: true };
   });
-  server2.post("/_web/ai/conversations/:id/messages/:messageId/delete-relink", async (request, reply) => {
+  server2.post("/_web/ai/chats/:id/messages/:messageId/delete-relink", async (request, reply) => {
     const { id, messageId } = request.params;
     if (!id || !messageId) {
-      return reply.code(400).send({ error: "conversation id and messageId are required" });
+      return reply.code(400).send({ error: "aiChatId and messageId are required" });
     }
     cm.deleteAndRelinkMessage(id, messageId);
     return { success: true };
   });
-  server2.post("/_web/ai/conversations/:id/messages/insert-after", async (request, reply) => {
+  server2.post("/_web/ai/chats/:id/messages/insert-after", async (request, reply) => {
     const { afterMessageId, role, content, contentBlocks, tokenUsage } = request.body;
     if (!afterMessageId || typeof afterMessageId !== "string") {
       return reply.code(400).send({ error: "afterMessageId is required" });
     }
     return cm.insertMessageAfter(request.params.id, afterMessageId, role, content, contentBlocks, tokenUsage);
   });
-  server2.get("/_web/ai/conversations/:id/token-usage", async (request) => {
-    return cm.getConversationTokenUsage(request.params.id);
+  server2.get("/_web/ai/chats/:id/token-usage", async (request) => {
+    return cm.getAIChatTokenUsage(request.params.id);
   });
   server2.get("/_web/ai/debug/schema", async () => {
     return cm.getAiSchema();
@@ -1362,7 +1355,7 @@ function registerAiConversationRoutes(server2, ctx) {
     const cleared = cm.clearAllDebugContext();
     return { success: true, cleared };
   });
-  server2.get("/_web/ai/conversations/:id/estimate-tokens", async (request) => {
+  server2.get("/_web/ai/chats/:id/estimate-tokens", async (request) => {
     const history = cm.getHistoryForAgent(request.params.id);
     const tokens = countMessagesTokens(history.map((m) => ({ role: m.role, content: m.content })));
     return { success: true, tokens, messageCount: history.length };
@@ -1389,8 +1382,8 @@ function registerAiSummaryRoutes(server2, ctx) {
   if (!deps) return;
   const { sessionAdapter: adapter } = ctx;
   server2.post("/_web/sessions/:id/summaries/generate", async (request, reply) => {
-    const { chatSessionId, locale, forceRegenerate, strategy } = request.body;
-    const result = await summary_service_exports.generateSummary(adapter, request.params.id, chatSessionId, deps, {
+    const { segmentId, locale, forceRegenerate, strategy } = request.body;
+    const result = await summary_service_exports.generateSummary(adapter, request.params.id, segmentId, deps, {
       locale,
       forceRegenerate,
       strategy
@@ -1412,8 +1405,8 @@ function registerAiSummaryRoutes(server2, ctx) {
     return result;
   });
   server2.post("/_web/sessions/:id/summaries/check-can-generate", async (request) => {
-    const { chatSessionIds } = request.body;
-    return summary_service_exports.checkCanGenerate(adapter, request.params.id, chatSessionIds);
+    const { segmentIds } = request.body;
+    return summary_service_exports.checkCanGenerate(adapter, request.params.id, segmentIds);
   });
 }
 
@@ -1853,7 +1846,7 @@ function registerSharedRoutes(server2, ctx, options) {
   if (options?.requireAi) {
     const missing = [];
     if (!ctx.aiDataDir) missing.push("aiDataDir");
-    if (!ctx.conversationManager) missing.push("conversationManager");
+    if (!ctx.aiChatManager) missing.push("aiChatManager");
     if (!ctx.assistantManager) missing.push("assistantManager");
     if (!ctx.skillManagerCore) missing.push("skillManagerCore");
     if (!ctx.llmConfigStore) missing.push("llmConfigStore");
@@ -1871,7 +1864,7 @@ function registerSharedRoutes(server2, ctx, options) {
   registerAiAgentStreamRoutes(server2, ctx);
   registerAiFilterRoutes(server2, ctx);
   registerAiToolRoutes(server2, ctx);
-  registerAiConversationRoutes(server2, ctx);
+  registerAiChatRoutes(server2, ctx);
   registerAiSummaryRoutes(server2, ctx);
   registerMergeRoutes(server2, ctx);
   registerCacheRoutes(server2, ctx);
@@ -1929,8 +1922,9 @@ function createServer() {
   });
   server2.addHook("onRequest", authHook);
   server2.setErrorHandler((error, _request, reply) => {
-    if (error instanceof ApiError) {
-      reply.code(error.statusCode).send(errorResponse(error));
+    const apiError = apiErrorFromUnknown(error);
+    if (apiError) {
+      reply.code(apiError.statusCode).send(errorResponse(apiError));
       return;
     }
     if (error.statusCode === 413) {
@@ -2346,7 +2340,7 @@ function registerWebRoutes(server2, dbManager2, options) {
   const resolvedPathProvider = options?.pathProvider ?? fallbackPathProvider;
   const ai = options?.aiContext;
   const cliStreamImport = async (dm, filePath) => {
-    const { streamImport: streamImport2 } = await import("./stream-import-L6RJHH4L.mjs");
+    const { streamImport: streamImport2 } = await import("./stream-import-O3H3FGV2.mjs");
     const result = await streamImport2(dm, filePath);
     if (!result.sessionId) throw new Error("Import succeeded but no sessionId returned");
     return { sessionId: result.sessionId };
@@ -2382,7 +2376,7 @@ function registerWebRoutes(server2, dbManager2, options) {
       },
       ...ai && {
         aiDataDir: ai.aiDataDir,
-        conversationManager: ai.convManager,
+        aiChatManager: ai.aiChatManager,
         assistantManager: ai.assistantManager,
         skillManagerCore: ai.skillManagerCore,
         llmConfigStore: ai.llmConfigStore,
@@ -2442,24 +2436,6 @@ function registerProxyRoutes(server2) {
   });
 }
 
-// src/ai/logger.ts
-var logger = null;
-function initServerAiLogger(logsDir) {
-  if (!logger) {
-    logger = new AiLogger(logsDir);
-  }
-  return logger;
-}
-function getServerAiLogger() {
-  return logger;
-}
-function closeServerAiLogger() {
-  if (logger) {
-    logger.close();
-    logger = null;
-  }
-}
-
 // src/ai/manager-factory.ts
 import * as fs5 from "fs";
 import * as path7 from "path";
@@ -2519,435 +2495,14 @@ function getSkillManagerCore(aiDataDir) {
   return cached.skill;
 }
 
-// src/ai/tool-adapter.ts
-var DEFAULT_MAX_TOOL_RESULT_TOKENS = 8e3;
-var TOOL_TRUNCATION_STRATEGY = {
-  search_messages: "keep_first",
-  deep_search_messages: "keep_first",
-  get_recent_messages: "keep_last",
-  get_message_context: "keep_last",
-  get_session_messages: "keep_last",
-  get_conversation_between: "keep_last"
-};
-function convertJsonSchemaToParameters(schema) {
-  const properties = {};
-  for (const [key, prop] of Object.entries(schema.properties)) {
-    properties[key] = { ...prop };
-  }
-  return {
-    type: "object",
-    properties,
-    required: schema.required || []
-  };
-}
-function adaptToolsForAgent(tools, getContext, options) {
-  const tokenBudget = options?.maxToolResultTokens ?? DEFAULT_MAX_TOOL_RESULT_TOKENS;
-  const chartSchemaGateState = createChartSchemaGateState();
-  return tools.map(
-    (tool) => wrapWithChartSchemaGate(
-      {
-        name: tool.name,
-        label: tool.name,
-        description: tool.description,
-        parameters: convertJsonSchemaToParameters(tool.inputSchema),
-        async execute(_toolCallId, params) {
-          const toolParams = params && typeof params === "object" ? params : {};
-          const ctx = getContext();
-          const execCtx = {
-            db: ctx.db,
-            dataProvider: new CoreDataProvider(ctx.db),
-            sessionId: ctx.sessionId,
-            locale: ctx.locale,
-            segmentText: (texts, locale, options2) => batchSegmentWithFrequency(texts, locale, options2)
-          };
-          try {
-            const result = await tool.handler(toolParams, execCtx);
-            const chartDetails = result.chart || result.charts ? {
-              ...result.chart ? { chart: result.chart } : {},
-              ...result.charts ? { charts: result.charts } : {}
-            } : {};
-            if (result.rawMessages && result.rawMessages.length > 0) {
-              const pipelineResult = applyPreprocessingPipeline({
-                rawMessages: result.rawMessages,
-                locale: ctx.locale,
-                maxToolResultTokens: tokenBudget,
-                truncationStrategy: TOOL_TRUNCATION_STRATEGY[tool.name] ?? "keep_last",
-                extraDetails: result.data ?? {},
-                logger: getServerAiLogger() ?? void 0
-              });
-              return {
-                content: [{ type: "text", text: pipelineResult.text }],
-                details: Object.keys(chartDetails).length > 0 ? chartDetails : null
-              };
-            }
-            const baseDetails = typeof result.data === "object" && result.data !== null ? result.data : result.data === void 0 ? null : { value: result.data };
-            return {
-              content: [{ type: "text", text: result.content }],
-              details: Object.keys(chartDetails).length > 0 ? { ...baseDetails ?? {}, ...chartDetails } : baseDetails
-            };
-          } catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            return { content: [{ type: "text", text: `Error: ${msg}` }], details: null };
-          }
-        }
-      },
-      chartSchemaGateState
-    )
-  );
-}
-
-// src/ai/llm-config.ts
-import * as fs6 from "fs";
-import * as path8 from "path";
-function loadLlmConfig(aiDataDir) {
-  const configPath = path8.join(aiDataDir, "llm-config.json");
-  if (!fs6.existsSync(configPath)) {
-    return { configs: [], defaultAssistant: null, fastModel: null };
-  }
-  try {
-    const data = JSON.parse(fs6.readFileSync(configPath, "utf-8"));
-    const configs = (data.configs || []).map((c) => {
-      const provider = c.provider || "";
-      const authProfile = c.authProfile;
-      const profileKey = resolveApiKey(provider, authProfile);
-      const rawKey = c.apiKey || "";
-      const fallbackKey = rawKey.startsWith("enc:") ? "" : rawKey;
-      return {
-        ...c,
-        apiKey: profileKey || fallbackKey
-      };
-    });
-    return {
-      configs,
-      defaultAssistant: data.defaultAssistant ?? null,
-      fastModel: data.fastModel ?? null
-    };
-  } catch {
-    return { configs: [], defaultAssistant: null, fastModel: null };
-  }
-}
-function resolveSlot(slot, configs) {
-  if (slot && configs.some((c) => c.id === slot.configId)) return slot;
-  const fallback = configs[0];
-  if (!fallback) return null;
-  return { configId: fallback.id, modelId: fallback.model };
-}
-function getDefaultAssistantConfig(aiDataDir) {
-  const store = loadLlmConfig(aiDataDir);
-  const slot = resolveSlot(store.defaultAssistant, store.configs);
-  if (!slot) return null;
-  const config = store.configs.find((c) => c.id === slot.configId);
-  if (!config) return null;
-  return { ...config, model: slot.modelId || config.model };
-}
-function buildPiModel2(config) {
-  return buildPiModel(config);
-}
-
-// src/ai/assistant-loader.ts
-import * as fs7 from "fs";
-import * as path9 from "path";
-function loadAssistantConfig(aiDataDir, assistantId) {
-  const filePath = path9.join(aiDataDir, "assistants", `${assistantId}.md`);
-  if (!fs7.existsSync(filePath)) return null;
-  try {
-    const content = fs7.readFileSync(filePath, "utf-8");
-    return parseAssistantFile(content, filePath);
-  } catch {
-    return null;
-  }
-}
-
-// src/ai/agent.ts
-async function runServerAgent(options) {
-  const {
-    userMessage,
-    conversationId,
-    historyLeafMessageId,
-    chatType = "group",
-    locale = "zh-CN",
-    assistantSystemPrompt,
-    skillMenu,
-    skillDef,
-    compressionConfig,
-    tools = [],
-    aiDataDir,
-    convManager: convManager2,
-    onEvent,
-    abortSignal,
-    ownerInfo,
-    mentionedMembers,
-    dataSnapshot,
-    thinkingLevel
-  } = options;
-  const aiLogger = getServerAiLogger();
-  await initTokenizer();
-  const llmConfig = getDefaultAssistantConfig(aiDataDir);
-  if (!llmConfig) {
-    onEvent({ type: "error", error: { name: "ConfigError", message: "LLM service not configured" } });
-    onEvent({ type: "done", isFinished: true });
-    return;
-  }
-  const piModel = buildPiModel2(llmConfig);
-  const t = createAiTranslate(locale);
-  let skillCtx;
-  if (skillDef) {
-    skillCtx = { skillDef };
-  } else if (skillMenu) {
-    skillCtx = { skillMenu };
-  }
-  const systemPrompt = buildSystemPrompt({
-    t,
-    chatType,
-    assistantSystemPrompt,
-    ownerInfo,
-    locale,
-    skillCtx,
-    mentionedMembers,
-    dataSnapshot
-  });
-  const handler = new AgentEventHandler({
-    onChunk: onEvent,
-    context: {},
-    systemPrompt
-  });
-  if (compressionConfig?.enabled && historyLeafMessageId === void 0) {
-    const llmAdapter = createCompressionLlmAdapter({
-      piModel,
-      apiKey: llmConfig.apiKey,
-      onCompressing: () => handler.emitStatus("compressing", [])
-    });
-    const compressionResult = await checkAndCompress(
-      conversationId,
-      compressionConfig,
-      systemPrompt,
-      llmAdapter,
-      convManager2,
-      aiLogger ?? void 0
-    );
-    if (compressionResult.compressed) {
-      onEvent({
-        type: "compression_done",
-        compressionResult: {
-          summaryContent: compressionResult.summaryContent ?? "",
-          tokensBefore: compressionResult.tokensBefore ?? 0,
-          tokensAfter: compressionResult.tokensAfter ?? 0,
-          timestamp: Date.now()
-        }
-      });
-    }
-  } else if (compressionConfig?.enabled && historyLeafMessageId !== void 0) {
-    aiLogger?.info?.("Compression", "Skipping compression for edited branch request", {
-      conversationId,
-      historyLeafMessageId
-    });
-  }
-  if (abortSignal?.aborted) {
-    handler.emitStatus("aborted", [], { force: true });
-    onEvent({ type: "done", isFinished: true, usage: handler.cloneUsage() });
-    return;
-  }
-  let history = [];
-  try {
-    history = convManager2.getHistoryForAgent(conversationId, void 0, historyLeafMessageId);
-  } catch {
-  }
-  handler.emitStatus("preparing", [], { pendingUserMessage: userMessage, force: true });
-  const steerMessage = t("ai.agent.answerWithoutTools");
-  let cachedMessages = [];
-  try {
-    const result = await runAgentCore({
-      piModel,
-      apiKey: llmConfig.apiKey,
-      systemPrompt,
-      tools,
-      history,
-      userMessage,
-      maxToolRounds: DEFAULT_MAX_TOOL_ROUNDS,
-      abortSignal,
-      steerMessage,
-      thinkingLevel,
-      onConvertToLlm: (filteredMessages) => {
-        cachedMessages = filteredMessages;
-      },
-      onEvent: (coreEvent) => handler.handleCoreEvent(coreEvent, cachedMessages),
-      onDebugContext: (messages) => {
-        try {
-          convManager2.setPendingDebugContext(conversationId, JSON.stringify(messages, null, 2));
-        } catch {
-        }
-      }
-    });
-    if (result.error) {
-      const friendlyMessage = formatAIError(result.error);
-      onEvent({ type: "error", error: { name: "AgentError", message: friendlyMessage } });
-    }
-    handler.emitStatus("completed", cachedMessages, { force: true });
-    onEvent({ type: "done", isFinished: true, usage: result.usage });
-  } catch (error) {
-    const friendlyMessage = formatAIError(error);
-    aiLogger?.error("ServerAgent", "Agent execution error", { error: String(error) });
-    handler.emitStatus("error", cachedMessages, { force: true });
-    onEvent({ type: "error", error: { name: "AgentError", message: friendlyMessage } });
-    onEvent({ type: "done", isFinished: true, usage: handler.cloneUsage() });
-  }
-}
-
-// src/ai/agent-stream-runner.ts
-function getAiDir(dbManager2) {
-  const pathProvider = dbManager2["pathProvider"];
-  if (!pathProvider) {
-    throw Object.assign(new Error("PathProvider not available"), { statusCode: 500 });
-  }
-  return pathProvider.getAiDataDir();
-}
-var RAW_SQL_TOOL_NAMES = /* @__PURE__ */ new Set(["execute_sql"]);
-function getAvailableToolDefs(isChartCapability, allowedToolSet) {
-  if (isChartCapability) {
-    const chartCoreTools = new Set(CHART_CAPABILITY_CORE_TOOLS);
-    return AGENT_TOOL_REGISTRY.filter(
-      (tool) => chartCoreTools.has(tool.name) || tool.category === "analysis" && allowedToolSet?.has(tool.name) && !RAW_SQL_TOOL_NAMES.has(tool.name)
-    );
-  }
-  return allowedToolSet ? AGENT_TOOL_REGISTRY.filter((tool) => tool.category !== "analysis" || allowedToolSet.has(tool.name)) : AGENT_TOOL_REGISTRY;
-}
-function getAllowedToolSet(isChartCapability, allowedBuiltinTools) {
-  if (isChartCapability) {
-    return new Set(allowedBuiltinTools);
-  }
-  return allowedBuiltinTools === void 0 ? null : new Set(allowedBuiltinTools);
-}
-function createCliRunAgentStream(dbManager2, convManager2) {
-  return async (params, onEvent, abortSignal) => {
-    const {
-      userMessage,
-      conversationId,
-      historyLeafMessageId,
-      sessionId,
-      chatType,
-      locale,
-      assistantId,
-      skillId,
-      enableAutoSkill,
-      compressionConfig,
-      ownerInfo,
-      mentionedMembers,
-      thinkingLevel
-    } = params;
-    const aiDataDir = getAiDir(dbManager2);
-    let assistantSystemPrompt;
-    let assistantAllowedTools;
-    if (assistantId) {
-      const assistantConfig = loadAssistantConfig(aiDataDir, assistantId);
-      if (assistantConfig?.systemPrompt) {
-        assistantSystemPrompt = assistantConfig.systemPrompt;
-      }
-      assistantAllowedTools = assistantConfig?.allowedBuiltinTools;
-    }
-    const llmConfig = getDefaultAssistantConfig(aiDataDir);
-    const maxToolResultPercent = compressionConfig?.maxToolResultPercent ?? 50;
-    const contextWindow = llmConfig ? buildPiModel2(llmConfig).contextWindow ?? 128e3 : 128e3;
-    const maxToolResultTokens = Math.floor(contextWindow * (maxToolResultPercent / 100));
-    const db = dbManager2.open?.(sessionId);
-    const chartRuntime = resolveChartRuntimeForRequest({
-      skillId,
-      userMessage,
-      locale,
-      assistantAllowedTools
-    });
-    const isChartCapability = chartRuntime.isChartCapability;
-    const autoSkillAllowedTools = !skillId && enableAutoSkill ? getAllowedBuiltinToolsForChartAutoSkill(assistantAllowedTools) : assistantAllowedTools;
-    const allowedToolSet = getAllowedToolSet(
-      isChartCapability,
-      isChartCapability ? chartRuntime.allowedBuiltinTools : autoSkillAllowedTools
-    );
-    const availableToolDefs = getAvailableToolDefs(isChartCapability, allowedToolSet);
-    const agentTools = db ? adaptToolsForAgent(availableToolDefs, () => ({ db, sessionId, locale }), { maxToolResultTokens }) : [];
-    const skillMgr = new SkillManager(aiDataDir);
-    skillMgr.init();
-    const toolNames = agentTools.map((t) => t.name);
-    let resolvedSkillDef;
-    let resolvedSkillMenu;
-    if (isChartCapability) {
-      const def = chartRuntime.skillDef ?? getChartCapabilitySkill(locale ?? "zh-CN");
-      resolvedSkillDef = { name: def.name, prompt: def.prompt };
-    } else if (skillId) {
-      const def = skillMgr.getSkillConfig(skillId);
-      if (def) resolvedSkillDef = { name: def.name, prompt: def.prompt };
-    } else if (enableAutoSkill) {
-      const menu = buildSkillMenuWithBuiltinChart(
-        skillMgr.getSkillMenu(chatType ?? "group", toolNames),
-        locale,
-        toolNames
-      );
-      if (menu) resolvedSkillMenu = menu;
-    }
-    if (resolvedSkillMenu) {
-      const activateSkillTool = createActivateSkillTool({
-        chatType: chatType ?? "group",
-        allowedTools: toolNames,
-        coreToolNames: new Set(CHART_CAPABILITY_CORE_TOOLS),
-        locale,
-        getSkillConfig: (id) => getSkillConfigWithBuiltinChart(id, locale, (skillConfigId) => skillMgr.getSkillConfig(skillConfigId))
-      });
-      agentTools.push(activateSkillTool);
-    }
-    const resolvedCompression = compressionConfig?.enabled ? {
-      enabled: true,
-      tokenThresholdPercent: compressionConfig.tokenThresholdPercent ?? 75,
-      bufferSizePercent: compressionConfig.bufferSizePercent ?? 20,
-      maxToolResultPercent: compressionConfig.maxToolResultPercent
-    } : void 0;
-    let dataSnapshot;
-    if (db) {
-      try {
-        const overview = getChatOverview(db, 5);
-        if (overview) {
-          dataSnapshot = {
-            name: overview.name,
-            platform: overview.platform,
-            type: overview.type,
-            totalMessages: overview.totalMessages,
-            totalMembers: overview.totalMembers,
-            firstMessageTs: overview.firstMessageTs,
-            lastMessageTs: overview.lastMessageTs,
-            capturedAt: Math.floor(Date.now() / 1e3)
-          };
-        }
-      } catch {
-      }
-    }
-    await runServerAgent({
-      userMessage,
-      conversationId,
-      historyLeafMessageId,
-      chatType,
-      locale,
-      assistantSystemPrompt,
-      skillMenu: resolvedSkillMenu,
-      skillDef: resolvedSkillDef,
-      compressionConfig: resolvedCompression,
-      tools: agentTools,
-      aiDataDir,
-      convManager: convManager2,
-      onEvent,
-      abortSignal,
-      ownerInfo,
-      mentionedMembers,
-      dataSnapshot,
-      thinkingLevel
-    });
-  };
-}
-
 // ../../packages/sync/src/types.ts
 var noop = () => {
 };
 var NOOP_LOGGER = { info: noop, warn: noop, error: noop };
 
 // ../../packages/sync/src/data-source-manager.ts
-import * as fs8 from "fs";
-import * as path10 from "path";
+import * as fs6 from "fs";
+import * as path8 from "path";
 import * as crypto from "crypto";
 var CONFIG_FILE = "data-sources.json";
 function generateId(prefix = "ds") {
@@ -2970,22 +2525,22 @@ function isValidDataSourceArray(data) {
 var DataSourceManager = class {
   configDir;
   logger;
-  constructor(configDir, logger2) {
+  constructor(configDir, logger) {
     this.configDir = configDir;
-    this.logger = logger2 ?? NOOP_LOGGER;
+    this.logger = logger ?? NOOP_LOGGER;
   }
   getConfigPath() {
-    return path10.join(this.configDir, CONFIG_FILE);
+    return path8.join(this.configDir, CONFIG_FILE);
   }
   ensureDir() {
-    fs8.mkdirSync(this.configDir, { recursive: true });
+    fs6.mkdirSync(this.configDir, { recursive: true });
   }
   // ==================== Load / Save ====================
   loadAll() {
     try {
       const filePath = this.getConfigPath();
-      if (fs8.existsSync(filePath)) {
-        const raw = fs8.readFileSync(filePath, "utf-8");
+      if (fs6.existsSync(filePath)) {
+        const raw = fs6.readFileSync(filePath, "utf-8");
         const parsed = JSON.parse(raw);
         if (!isValidDataSourceArray(parsed)) {
           this.logger.warn("[DataSource] Incompatible config format detected, returning empty.");
@@ -3004,7 +2559,7 @@ var DataSourceManager = class {
   saveAll(sources) {
     try {
       this.ensureDir();
-      fs8.writeFileSync(this.getConfigPath(), JSON.stringify(sources, null, 2), "utf-8");
+      fs6.writeFileSync(this.getConfigPath(), JSON.stringify(sources, null, 2), "utf-8");
     } catch (err) {
       this.logger.error("[DataSource] Failed to save config", err);
     }
@@ -3129,7 +2684,7 @@ function parseRemoteSessionsResponse(body) {
 }
 
 // ../../packages/sync/src/pull-engine.ts
-import * as fs9 from "fs";
+import * as fs7 from "fs";
 import * as crypto2 from "crypto";
 var MAX_PAGES_PER_PULL = 5e3;
 var PULL_OVERLAP_SECONDS = 60;
@@ -3149,7 +2704,7 @@ function parseSyncFromFile(filePath) {
   try {
     const isJsonl = filePath.endsWith(".jsonl");
     if (isJsonl) {
-      const content = fs9.readFileSync(filePath, "utf-8");
+      const content = fs7.readFileSync(filePath, "utf-8");
       const lines = content.trimEnd().split("\n");
       for (let i = lines.length - 1; i >= Math.max(0, lines.length - 5); i--) {
         try {
@@ -3168,7 +2723,7 @@ function parseSyncFromFile(filePath) {
       }
       return null;
     }
-    const raw = fs9.readFileSync(filePath, "utf-8");
+    const raw = fs7.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.sync && typeof parsed.sync === "object") {
       const s = parsed.sync;
@@ -3182,7 +2737,7 @@ function parseSyncFromFile(filePath) {
 function fileContainsMessages(filePath) {
   try {
     if (filePath.endsWith(".jsonl")) {
-      const content = fs9.readFileSync(filePath, "utf-8");
+      const content = fs7.readFileSync(filePath, "utf-8");
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed) continue;
@@ -3195,7 +2750,7 @@ function fileContainsMessages(filePath) {
       }
       return false;
     }
-    const raw = fs9.readFileSync(filePath, "utf-8");
+    const raw = fs7.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed.messages) && parsed.messages.length > 0;
   } catch {
@@ -3204,7 +2759,7 @@ function fileContainsMessages(filePath) {
 }
 function cleanupTempFile(filePath) {
   try {
-    if (fs9.existsSync(filePath)) fs9.unlinkSync(filePath);
+    if (fs7.existsSync(filePath)) fs7.unlinkSync(filePath);
   } catch {
   }
 }
@@ -3264,7 +2819,7 @@ var PullEngine = class {
           limit: ds.pullLimit
         });
         try {
-          const stat2 = fs9.statSync(tempFile);
+          const stat2 = fs7.statSync(tempFile);
           this.logger.info(`[Pull] "${sess.name}" page ${pageCount}: fetched ${stat2.size} bytes`);
           const sync0 = parseSyncFromFile(tempFile);
           if (stat2.size < 1024) {
@@ -3282,7 +2837,7 @@ var PullEngine = class {
                   since,
                   limit: ds.pullLimit
                 });
-                const retryStat = fs9.statSync(retryFile);
+                const retryStat = fs7.statSync(retryFile);
                 this.logger.info(`[Pull] "${sess.name}" retry ${ri + 1}: fetched ${retryStat.size} bytes`);
                 const retrySync = parseSyncFromFile(retryFile);
                 if (retryStat.size < 1024 && !fileContainsMessages(retryFile) && retrySync?.hasMore === false) {
@@ -3556,13 +3111,13 @@ function reloadTimer(dsId, skipInitialPull = false) {
 }
 
 // src/sync/adapters.ts
-import * as fs10 from "fs";
+import * as fs8 from "fs";
 import * as os4 from "os";
-import * as path11 from "path";
+import * as path9 from "path";
 import * as crypto3 from "crypto";
 function getTempFilePath(ext) {
   const id = crypto3.randomBytes(8).toString("hex");
-  return path11.join(os4.tmpdir(), `chatlab-pull-${id}${ext}`);
+  return path9.join(os4.tmpdir(), `chatlab-pull-${id}${ext}`);
 }
 var NodeFetcher = class {
   async fetchToTempFile(baseUrl, remoteSessionId, token, params) {
@@ -3579,45 +3134,38 @@ var NodeFetcher = class {
     const isJsonl = contentType.includes("ndjson") || contentType.includes("jsonl");
     const tempFile = getTempFilePath(isJsonl ? ".jsonl" : ".json");
     const buffer = Buffer.from(await response.arrayBuffer());
-    fs10.writeFileSync(tempFile, buffer);
+    fs8.writeFileSync(tempFile, buffer);
     return tempFile;
   }
 };
-function resolveNativeBinding2() {
-  if (process.versions.electron) return void 0;
-  const nativePath = resolveCliPath("native/better_sqlite3.node");
-  if (fs10.existsSync(nativePath)) return nativePath;
-  return void 0;
-}
 var DirectImporter = class {
   dbManager;
-  nativeBinding;
   logger;
-  constructor(dbManager2, logger2) {
+  constructor(dbManager2, logger) {
     this.dbManager = dbManager2;
-    this.nativeBinding = resolveNativeBinding2();
-    this.logger = logger2 ?? NOOP_LOGGER;
+    this.logger = logger ?? NOOP_LOGGER;
   }
   sessionExists(sessionId) {
     const dbPath = this.dbManager.getDbPath(sessionId);
-    if (!fs10.existsSync(dbPath)) return false;
+    if (!fs8.existsSync(dbPath)) return false;
     try {
-      const db = openBetterSqliteDatabase(dbPath, { readonly: true, nativeBinding: this.nativeBinding });
+      const db = this.dbManager.openRawSessionDatabase(sessionId, { readonly: true });
       const row = db.prepare("SELECT COUNT(*) as cnt FROM sqlite_master WHERE type='table' AND name='message'").get();
       db.close();
       if (row.cnt === 0) {
         this.logger.warn(`[DirectImporter] DB file exists but has no message table: ${sessionId}, removing`);
         try {
-          fs10.unlinkSync(dbPath);
+          fs8.unlinkSync(dbPath);
         } catch {
         }
         return false;
       }
       return true;
-    } catch {
+    } catch (error) {
+      if (error instanceof DataDirCompatibilityError) throw error;
       this.logger.warn(`[DirectImporter] Cannot validate DB file: ${sessionId}, removing`);
       try {
-        fs10.unlinkSync(dbPath);
+        fs8.unlinkSync(dbPath);
       } catch {
       }
       return false;
@@ -3638,8 +3186,7 @@ var DirectImporter = class {
       const data = await parseFile(tempFile);
       this.dbManager.close(sessionId);
       const result = await importData(this.dbManager, data, {
-        sessionId,
-        nativeBinding: this.nativeBinding
+        sessionId
       });
       if (result.success) {
         this.logger.info(
@@ -3664,8 +3211,7 @@ var DirectImporter = class {
     try {
       const data = await parseFile(tempFile);
       const result = await importData(this.dbManager, data, {
-        sessionId: externalId,
-        nativeBinding: this.nativeBinding
+        sessionId: externalId
       });
       if (result.success) {
         this.logger.info(
@@ -3737,8 +3283,8 @@ function registerAutomationRoutes(server2, ctx) {
     if (request.query.deleteData === "true" && removed.targetSessionId) {
       dbManager2.close(removed.targetSessionId);
       const dbPath = dbManager2.getDbPath(removed.targetSessionId);
-      const fs12 = await import("fs");
-      if (fs12.existsSync(dbPath)) fs12.unlinkSync(dbPath);
+      const fs10 = await import("fs");
+      if (fs10.existsSync(dbPath)) fs10.unlinkSync(dbPath);
     }
     return { success: true };
   });
@@ -3813,26 +3359,26 @@ function cleanupSync() {
 // src/http/index.ts
 var server = null;
 var dbManager = null;
-var convManager = null;
+var aiChatManager = null;
 function createFileConfigStorage(aiDataDir) {
   return {
     readJson(key) {
       try {
-        return JSON.parse(fs11.readFileSync(`${aiDataDir}/${key}.json`, "utf-8"));
+        return JSON.parse(fs9.readFileSync(`${aiDataDir}/${key}.json`, "utf-8"));
       } catch {
         return null;
       }
     },
     writeJson(key, data) {
-      if (!fs11.existsSync(aiDataDir)) fs11.mkdirSync(aiDataDir, { recursive: true });
-      fs11.writeFileSync(`${aiDataDir}/${key}.json`, JSON.stringify(data, null, 2), "utf-8");
+      if (!fs9.existsSync(aiDataDir)) fs9.mkdirSync(aiDataDir, { recursive: true });
+      fs9.writeFileSync(`${aiDataDir}/${key}.json`, JSON.stringify(data, null, 2), "utf-8");
     }
   };
 }
-function resolveNativeBinding3() {
+function resolveNativeBinding2() {
   if (process.versions.electron) return void 0;
   const nativePath = resolveCliPath("native/better_sqlite3.node");
-  if (fs11.existsSync(nativePath)) return nativePath;
+  if (fs9.existsSync(nativePath)) return nativePath;
   return void 0;
 }
 function ensureToken(config) {
@@ -3864,6 +3410,7 @@ async function startHttpServer(options) {
   const userDataDir = config.data.user_data_dir || void 0;
   const pathProvider = new NodePathProvider(userDataDir);
   pathProvider.ensureAllDirs();
+  const runtime = assertCliDataDirCompatible(pathProvider, "cli");
   if (hasPendingElectronDataWarning() || !verifyCliDataPath(pathProvider.getDatabaseDir())) {
     console.error(
       "\n" + "=".repeat(68) + "\n  ChatLab: Electron desktop data not found\n" + "=".repeat(68) + '\n\n  Detected that ChatLab desktop app was installed on this machine,\n  but could not locate your chat databases.\n\n  This usually means you changed the data directory in desktop settings.\n\n  To fix this, choose one of:\n\n  1. Open ChatLab desktop app \u2014 it will auto-migrate your data\n  2. Set the data directory manually:\n     export CHATLAB_DATA_DIR="/path/to/your/data"\n  3. Edit ~/.chatlab/config.toml:\n     [data]\n     user_data_dir = "/path/to/your/data"\n\n' + "=".repeat(68) + "\n"
@@ -3879,10 +3426,10 @@ async function startHttpServer(options) {
     }
   });
   await migrationRunner.run();
-  const nativeBinding = resolveNativeBinding3();
-  dbManager = new DatabaseManager(pathProvider, { nativeBinding });
+  const nativeBinding = resolveNativeBinding2();
+  dbManager = new DatabaseManager(pathProvider, { nativeBinding, runtime });
   const aiDataDir = pathProvider.getAiDataDir();
-  convManager = new AIConversationManager(aiDataDir, { nativeBinding });
+  aiChatManager = new AIChatManager(aiDataDir, { nativeBinding });
   const assistantManager = getAssistantManager(aiDataDir);
   const skillManagerCore = getSkillManagerCore(aiDataDir);
   const llmConfigStore = new LLMConfigStore(createFileConfigStorage(aiDataDir), {
@@ -3907,17 +3454,17 @@ async function startHttpServer(options) {
     nativeBinding,
     aiContext: {
       aiDataDir,
-      convManager,
+      aiChatManager,
       assistantManager,
       skillManagerCore,
       llmConfigStore,
       customProviderStore: new CustomProviderStore(createFileConfigStorage(aiDataDir)),
       customModelStore: new CustomModelStore(createFileConfigStorage(aiDataDir)),
-      runAgentStream: createCliRunAgentStream(dbManager, convManager)
+      runAgentStream: createCliRunAgentStream(dbManager, aiChatManager)
     }
   });
   initSync(server, dbManager, pathProvider, { port, host, token });
-  if (options?.webRoot && fs11.existsSync(options.webRoot)) {
+  if (options?.webRoot && fs9.existsSync(options.webRoot)) {
     registerProxyRoutes(server);
     const fastifyStatic = await import("@fastify/static");
     await server.register(fastifyStatic.default, {
@@ -3938,9 +3485,9 @@ async function stopHttpServer() {
     await server.close();
   } finally {
     cleanupSync();
-    if (convManager) {
-      convManager.close();
-      convManager = null;
+    if (aiChatManager) {
+      aiChatManager.close();
+      aiChatManager = null;
     }
     if (dbManager) {
       dbManager.closeAll();
@@ -3958,4 +3505,4 @@ export {
   startHttpServer,
   stopHttpServer
 };
-//# sourceMappingURL=chunk-FSHVDWI2.mjs.map
+//# sourceMappingURL=chunk-SJIOPSMM.mjs.map