koishi-plugin-chatluna 1.3.13 → 1.3.15

package/lib/llm-core/agent/openai/index.d.ts

@@ -22,4 +22,4 @@ export type CreateOpenAIAgentParams = {
 };
 export declare function createOpenAIAgent({ llm, tools, prompt }: CreateOpenAIAgentParams): RunnableSequence<{
     steps: AgentStep[];
-}, AgentAction | AgentFinish | AgentAction[]>;
+}, AgentAction | AgentAction[] | AgentFinish>;

package/lib/llm-core/agent/openai/output_parser.d.ts

@@ -12,7 +12,7 @@ export declare class OpenAIFunctionsAgentOutputParser extends AgentActionOutputP
     lc_namespace: string[];
     static lc_name(): string;
     parse(text: string): Promise<AgentAction | AgentFinish>;
-    parseResult(generations: ChatGeneration[]): Promise<FunctionsAgentAction | AgentFinish>;
+    parseResult(generations: ChatGeneration[]): Promise<AgentFinish | FunctionsAgentAction>;
     /**
      * Parses the output message into a FunctionsAgentAction or AgentFinish
      * object.

package/lib/llm-core/agent/react/index.d.ts

@@ -72,7 +72,7 @@ export type CreateReactAgentParams = {
  */
 export declare function createReactAgent({ llm, tools, prompt, streamRunnable, instructions }: CreateReactAgentParams): AgentRunnableSequence<{
     steps: AgentStep[];
-}, import("koishi-plugin-chatluna/llm-core/agent").AgentFinish | import("koishi-plugin-chatluna/llm-core/agent").AgentAction[]>;
+}, import("koishi-plugin-chatluna/llm-core/agent").AgentAction[] | import("koishi-plugin-chatluna/llm-core/agent").AgentFinish>;
 /**
  * Construct the scratchpad that lets the agent continue its thought process.
  * @param intermediateSteps

package/lib/llm-core/chat/app.cjs

@@ -584,7 +584,7 @@ var ChatInterface = class {
   }
   async processChat(arg, wrapper) {
     try {
-      if (this.ctx.chatluna.config.infiniteContext) {
+      if (this.ctx.chatluna.currentConfig.infiniteContext) {
         const manager = this._ensureInfiniteContextManager();
         await manager?.compressIfNeeded(wrapper);
       }
@@ -615,7 +615,7 @@ var ChatInterface = class {
     if (messageContent.trim().length > 0) {
       await this.chatHistory.addMessage(arg.message);
       let saveMessage = responseMessage;
-      if (!this.ctx.chatluna.config.rawOnCensor) {
+      if (!this.ctx.chatluna.currentConfig.rawOnCensor) {
         saveMessage = displayResponse;
       }
       if (Array.isArray(response.parallelIntermediateSteps) && response.parallelIntermediateSteps.length > 0) {
@@ -885,7 +885,7 @@ var ChatInterface = class {
         chatHistory: this._chatHistory,
         conversationId: this._input.conversationId,
         preset: this._input.preset,
-        threshold: this.ctx.chatluna.config.infiniteContextThreshold
+        threshold: this.ctx.chatluna.currentConfig.infiniteContextThreshold
       });
     }
     return this._infiniteContextManager;

package/lib/llm-core/chat/app.mjs

@@ -578,7 +578,7 @@ var ChatInterface = class {
   }
   async processChat(arg, wrapper) {
     try {
-      if (this.ctx.chatluna.config.infiniteContext) {
+      if (this.ctx.chatluna.currentConfig.infiniteContext) {
         const manager = this._ensureInfiniteContextManager();
         await manager?.compressIfNeeded(wrapper);
       }
@@ -609,7 +609,7 @@ var ChatInterface = class {
     if (messageContent.trim().length > 0) {
       await this.chatHistory.addMessage(arg.message);
       let saveMessage = responseMessage;
-      if (!this.ctx.chatluna.config.rawOnCensor) {
+      if (!this.ctx.chatluna.currentConfig.rawOnCensor) {
         saveMessage = displayResponse;
       }
       if (Array.isArray(response.parallelIntermediateSteps) && response.parallelIntermediateSteps.length > 0) {
@@ -879,7 +879,7 @@ var ChatInterface = class {
         chatHistory: this._chatHistory,
         conversationId: this._input.conversationId,
         preset: this._input.preset,
-        threshold: this.ctx.chatluna.config.infiniteContextThreshold
+        threshold: this.ctx.chatluna.currentConfig.infiniteContextThreshold
       });
     }
     return this._infiniteContextManager;

package/lib/services/chat.cjs

@@ -1198,6 +1198,7 @@ var ChatLunaService = class extends import_koishi4.Service {
   _messageTransformer;
   _renderer;
   _promptRenderer;
+  config;
   async installPlugin(plugin) {
     const platformName = plugin.platformName;
     if (this._plugins[platformName]) {
@@ -1823,7 +1824,7 @@ var ChatInterfaceWrapper = class {
       const reasoningContent = aiMessage.additional_kwargs?.reasoning_content;
       const reasoningTime = aiMessage.additional_kwargs?.reasoning_time;
       const additionalReplyMessages = [];
-      if (reasoningContent != null && reasoningContent.length > 0 && this._service.config.showThoughtMessage) {
+      if (reasoningContent != null && reasoningContent.length > 0 && this._service.currentConfig.showThoughtMessage) {
         additionalReplyMessages.push({
           content: `Thought for ${reasoningTime / 1e3} seconds: 
 
@@ -1968,7 +1969,7 @@ ${reasoningContent}`
     this._platformToConversations.delete(platform);
   }
   async _createChatInterface(room) {
-    const config = this._service.config;
+    const config = this._service.currentConfig;
     const chatInterface = new import_app.ChatInterface(this._service.ctx.root, {
       chatMode: room.chatMode,
       botName: config.botNames[0],

package/lib/services/chat.d.ts

@@ -1,211 +1,127 @@
-import {
-    Awaitable,
-    Computed,
-    Context,
-    Dict,
-    Schema,
-    Service,
-    Session
-} from 'koishi'
-import { ChatInterface } from 'koishi-plugin-chatluna/llm-core/chat/app'
-import { Cache } from '../cache'
-import { ChatChain } from '../chains/chain'
-import { ChatLunaLLMChainWrapper } from 'koishi-plugin-chatluna/llm-core/chain/base'
-import { BasePlatformClient } from 'koishi-plugin-chatluna/llm-core/platform/client'
-import {
-    ClientConfig,
-    ClientConfigPool
-} from 'koishi-plugin-chatluna/llm-core/platform/config'
-import { ChatLunaChatModel } from 'koishi-plugin-chatluna/llm-core/platform/model'
-import { PlatformService } from 'koishi-plugin-chatluna/llm-core/platform/service'
-import {
-    ChatLunaTool,
-    CreateChatLunaLLMChainParams,
-    CreateVectorStoreFunction,
-    PlatformClientNames
-} from 'koishi-plugin-chatluna/llm-core/platform/types'
-import { PresetService } from 'koishi-plugin-chatluna/preset'
-import { ConversationRoom, Message } from '../types'
-import { MessageTransformer } from './message_transform'
-import { ChatEvents } from './types'
-import * as fetchType from 'undici/types/fetch'
-import { ClientOptions, WebSocket } from 'ws'
-import { ClientRequestArgs } from 'http'
-import { Config } from '../config'
-import { DefaultRenderer, Renderer } from 'koishi-plugin-chatluna'
-import type { PostHandler } from '../utils/types'
-import { ChatLunaPromptRenderService } from './prompt_renderer'
-import { ComputedRef } from '@vue/reactivity'
-import { Embeddings } from '@langchain/core/embeddings'
-export declare class ChatLunaService extends Service {
-    readonly ctx: Context
-    currentConfig: Config
-    private _plugins
-    private _chatInterfaceWrapper
-    private readonly _chain
-    private readonly _keysCache
-    private readonly _preset
-    private readonly _platformService
-    private readonly _messageTransformer
-    private readonly _renderer
-    private readonly _promptRenderer
-    constructor(ctx: Context, config: Config)
-    installPlugin(plugin: ChatLunaPlugin): Promise<void>
-    awaitLoadPlatform(
-        plugin: ChatLunaPlugin | string,
-        timeout?: number
-    ): Promise<void>
-
-    uninstallPlugin(plugin: ChatLunaPlugin | string): void
-    getPlugin(
-        platformName: string
-    ): ChatLunaPlugin<ClientConfig, ChatLunaPlugin.Config>
-
+import { Awaitable, Computed, Context, Dict, Schema, Service, Session } from 'koishi';
+import { ChatInterface } from 'koishi-plugin-chatluna/llm-core/chat/app';
+import { Cache } from '../cache';
+import { ChatChain } from '../chains/chain';
+import { ChatLunaLLMChainWrapper } from 'koishi-plugin-chatluna/llm-core/chain/base';
+import { BasePlatformClient } from 'koishi-plugin-chatluna/llm-core/platform/client';
+import { ClientConfig, ClientConfigPool } from 'koishi-plugin-chatluna/llm-core/platform/config';
+import { ChatLunaChatModel } from 'koishi-plugin-chatluna/llm-core/platform/model';
+import { PlatformService } from 'koishi-plugin-chatluna/llm-core/platform/service';
+import { ChatLunaTool, CreateChatLunaLLMChainParams, CreateVectorStoreFunction, PlatformClientNames } from 'koishi-plugin-chatluna/llm-core/platform/types';
+import { PresetService } from 'koishi-plugin-chatluna/preset';
+import { ConversationRoom, Message } from '../types';
+import { MessageTransformer } from './message_transform';
+import { ChatEvents } from './types';
+import * as fetchType from 'undici/types/fetch';
+import { ClientOptions, WebSocket } from 'ws';
+import { ClientRequestArgs } from 'http';
+import { Config } from '../config';
+import { DefaultRenderer, Renderer } from 'koishi-plugin-chatluna';
+import type { PostHandler } from '../utils/types';
+import { ChatLunaPromptRenderService } from './prompt_renderer';
+import { ComputedRef } from '@vue/reactivity';
+import { Embeddings } from '@langchain/core/embeddings';
+export declare class ChatLunaService extends Service<Config> {
+    readonly ctx: Context;
+    private _plugins;
+    private _chatInterfaceWrapper;
+    private readonly _chain;
+    private readonly _keysCache;
+    private readonly _preset;
+    private readonly _platformService;
+    private readonly _messageTransformer;
+    private readonly _renderer;
+    private readonly _promptRenderer;
+    config: Config;
+    constructor(ctx: Context, config: Config);
+    installPlugin(plugin: ChatLunaPlugin): Promise<void>;
+    awaitLoadPlatform(plugin: ChatLunaPlugin | string, timeout?: number): Promise<void>;
+    uninstallPlugin(plugin: ChatLunaPlugin | string): void;
+    getPlugin(platformName: string): ChatLunaPlugin<ClientConfig, ChatLunaPlugin.Config>;
     /**
      * @internal
      */
-    chat(
-        session: Session,
-        room: ConversationRoom,
-        message: Message,
-        event: ChatEvents,
-        stream?: boolean,
-        variables?: Record<string, any>,
-        postHandler?: PostHandler,
-        requestId?: string
-    ): Promise<Message>
-
-    stopChat(room: ConversationRoom, requestId: string): Promise<boolean>
-    queryInterfaceWrapper(
-        room: ConversationRoom,
-        autoCreate?: boolean
-    ): ChatInterfaceWrapper
-
-    clearChatHistory(room: ConversationRoom): Promise<void>
-    compressContext(room: ConversationRoom): Promise<boolean>
-    getCachedInterfaceWrapper(): ChatInterfaceWrapper
-    clearCache(room: ConversationRoom): Promise<boolean>
-    createChatModel(
-        platform: string,
-        modelName: string
-    ): Promise<ComputedRef<ChatLunaChatModel | undefined>>
-
-    createChatModel(
-        fullModelName: string
-    ): Promise<ComputedRef<ChatLunaChatModel | undefined>>
-
-    createEmbeddings(
-        platformName: string,
-        modelName: string
-    ): Promise<ComputedRef<Embeddings | undefined>>
-
-    createEmbeddings(
-        fullModelName: string
-    ): Promise<ComputedRef<Embeddings | undefined>>
-
-    get platform(): PlatformService
-    get cache(): Cache<'chatluna/keys', string>
-    get preset(): PresetService
-    get chatChain(): ChatChain
-    get messageTransformer(): MessageTransformer
-    get renderer(): DefaultRenderer
-    get promptRenderer(): ChatLunaPromptRenderService
-    protected stop(): Promise<void>
-    private _createTempDir
-    private _defineDatabase
-    private _createChatInterfaceWrapper
-    static inject: string[]
+    chat(session: Session, room: ConversationRoom, message: Message, event: ChatEvents, stream?: boolean, variables?: Record<string, any>, postHandler?: PostHandler, requestId?: string): Promise<Message>;
+    stopChat(room: ConversationRoom, requestId: string): Promise<boolean>;
+    queryInterfaceWrapper(room: ConversationRoom, autoCreate?: boolean): ChatInterfaceWrapper;
+    clearChatHistory(room: ConversationRoom): Promise<void>;
+    compressContext(room: ConversationRoom): Promise<boolean>;
+    getCachedInterfaceWrapper(): ChatInterfaceWrapper;
+    clearCache(room: ConversationRoom): Promise<boolean>;
+    createChatModel(platform: string, modelName: string): Promise<ComputedRef<ChatLunaChatModel | undefined>>;
+    createChatModel(fullModelName: string): Promise<ComputedRef<ChatLunaChatModel | undefined>>;
+    createEmbeddings(platformName: string, modelName: string): Promise<ComputedRef<Embeddings | undefined>>;
+    createEmbeddings(fullModelName: string): Promise<ComputedRef<Embeddings | undefined>>;
+    get platform(): PlatformService;
+    get cache(): Cache<"chatluna/keys", string>;
+    get preset(): PresetService;
+    get chatChain(): ChatChain;
+    get messageTransformer(): MessageTransformer;
+    get renderer(): DefaultRenderer;
+    get promptRenderer(): ChatLunaPromptRenderService;
+    protected stop(): Promise<void>;
+    private _createTempDir;
+    private _defineDatabase;
+    private _createChatInterfaceWrapper;
+    static inject: string[];
 }
-export declare class ChatLunaPlugin<
-    R extends ClientConfig = ClientConfig,
-    T extends ChatLunaPlugin.Config = ChatLunaPlugin.Config
-> {
-    protected ctx: Context
-    readonly config: T
-    platformName: PlatformClientNames
-    private _supportModels
-    readonly platformConfigPool: ClientConfigPool<R>
-    private _platformService
-    constructor(
-        ctx: Context,
-        config: T,
-        platformName: PlatformClientNames,
-        createConfigPool?: boolean
-    )
-
-    parseConfig(f: (config: T) => R[]): void
-    private createRunnableConfig
-    initClient(): Promise<void>
-    get supportedModels(): readonly string[]
-    registerToService(): void
-    registerClient(func: () => BasePlatformClient, platformName?: string): void
-    registerVectorStore(name: string, func: CreateVectorStoreFunction): void
-    registerTool(name: string, tool: ChatLunaTool): void
-    registerChatChainProvider(
-        name: string,
-        description: Dict<string>,
-        func: (params: CreateChatLunaLLMChainParams) => ChatLunaLLMChainWrapper
-    ): void
-
-    registerRenderer(
-        name: string,
-        renderer: (ctx: Context, config: Config) => Renderer
-    ): void
-
-    fetch(
-        info: fetchType.RequestInfo,
-        init?: fetchType.RequestInit,
-        proxy?: string
-    ): Promise<fetchType.Response>
-
-    ws(url: string, options?: ClientOptions | ClientRequestArgs): WebSocket
+export declare class ChatLunaPlugin<R extends ClientConfig = ClientConfig, T extends ChatLunaPlugin.Config = ChatLunaPlugin.Config> {
+    protected ctx: Context;
+    readonly config: T;
+    platformName: PlatformClientNames;
+    private _supportModels;
+    readonly platformConfigPool: ClientConfigPool<R>;
+    private _platformService;
+    constructor(ctx: Context, config: T, platformName: PlatformClientNames, createConfigPool?: boolean);
+    parseConfig(f: (config: T) => R[]): void;
+    private createRunnableConfig;
+    initClient(): Promise<void>;
+    get supportedModels(): readonly string[];
+    registerToService(): void;
+    registerClient(func: () => BasePlatformClient, platformName?: string): void;
+    registerVectorStore(name: string, func: CreateVectorStoreFunction): void;
+    registerTool(name: string, tool: ChatLunaTool): void;
+    registerChatChainProvider(name: string, description: Dict<string>, func: (params: CreateChatLunaLLMChainParams) => ChatLunaLLMChainWrapper): void;
+    registerRenderer(name: string, renderer: (ctx: Context, config: Config) => Renderer): void;
+    fetch(info: fetchType.RequestInfo, init?: fetchType.RequestInit, proxy?: string): Promise<fetchType.Response>;
+    ws(url: string, options?: ClientOptions | ClientRequestArgs): WebSocket;
 }
 type ChatHubChatBridgerInfo = {
-    chatInterface: ChatInterface
-    room: ConversationRoom
-}
+    chatInterface: ChatInterface;
+    room: ConversationRoom;
+};
 declare class ChatInterfaceWrapper {
-    private _service
-    private _conversations
-    private _modelQueue
-    private _conversationQueue
-    private _platformService
-    private _requestIdMap
-    private _platformToConversations
-    constructor(_service: ChatLunaService)
-    chat(
-        session: Session,
-        room: ConversationRoom,
-        message: Message,
-        event: ChatEvents,
-        stream: boolean,
-        requestId: string,
-        variables?: Record<string, any>,
-        postHandler?: PostHandler
-    ): Promise<Message>
-
-    stopChat(requestId: string): boolean
-    query(room: ConversationRoom, create?: boolean): Promise<ChatInterface>
-    clearChatHistory(room: ConversationRoom): Promise<void>
-    compressContext(room: ConversationRoom): Promise<boolean>
-    clearCache(room: ConversationRoom): Promise<boolean>
-    getCachedConversations(): [string, ChatHubChatBridgerInfo][]
-    delete(room: ConversationRoom): Promise<void>
-    dispose(platform?: string): void
-    private _createChatInterface
+    private _service;
+    private _conversations;
+    private _modelQueue;
+    private _conversationQueue;
+    private _platformService;
+    private _requestIdMap;
+    private _platformToConversations;
+    constructor(_service: ChatLunaService);
+    chat(session: Session, room: ConversationRoom, message: Message, event: ChatEvents, stream: boolean, requestId: string, variables?: Record<string, any>, postHandler?: PostHandler): Promise<Message>;
+    stopChat(requestId: string): boolean;
+    query(room: ConversationRoom, create?: boolean): Promise<ChatInterface>;
+    clearChatHistory(room: ConversationRoom): Promise<void>;
+    compressContext(room: ConversationRoom): Promise<boolean>;
+    clearCache(room: ConversationRoom): Promise<boolean>;
+    getCachedConversations(): [string, ChatHubChatBridgerInfo][];
+    delete(room: ConversationRoom): Promise<void>;
+    dispose(platform?: string): void;
+    private _createChatInterface;
 }
 export declare namespace ChatLunaPlugin {
     interface Config {
-        chatConcurrentMaxSize?: number
-        chatTimeLimit?: Computed<Awaitable<number>>
-        timeout?: number
-        configMode: string
-        maxRetries: number
-        proxyMode: string
-        proxyAddress: string
+        chatConcurrentMaxSize?: number;
+        chatTimeLimit?: Computed<Awaitable<number>>;
+        timeout?: number;
+        configMode: string;
+        maxRetries: number;
+        proxyMode: string;
+        proxyAddress: string;
     }
-    const Config: Schema<ChatLunaPlugin.Config>
+    const Config: Schema<ChatLunaPlugin.Config>;
 }
-export * from './prompt_renderer'
-export * from './types'
-export * from './message_transform'
+export * from './prompt_renderer';
+export * from './types';
+export * from './message_transform';

package/lib/services/chat.mjs

@@ -1223,6 +1223,7 @@ var ChatLunaService = class extends Service {
   _messageTransformer;
   _renderer;
   _promptRenderer;
+  config;
   async installPlugin(plugin) {
     const platformName = plugin.platformName;
     if (this._plugins[platformName]) {
@@ -1848,7 +1849,7 @@ var ChatInterfaceWrapper = class {
       const reasoningContent = aiMessage.additional_kwargs?.reasoning_content;
       const reasoningTime = aiMessage.additional_kwargs?.reasoning_time;
       const additionalReplyMessages = [];
-      if (reasoningContent != null && reasoningContent.length > 0 && this._service.config.showThoughtMessage) {
+      if (reasoningContent != null && reasoningContent.length > 0 && this._service.currentConfig.showThoughtMessage) {
         additionalReplyMessages.push({
           content: `Thought for ${reasoningTime / 1e3} seconds: 
 
@@ -1993,7 +1994,7 @@ ${reasoningContent}`
     this._platformToConversations.delete(platform);
   }
   async _createChatInterface(room) {
-    const config = this._service.config;
+    const config = this._service.currentConfig;
     const chatInterface = new ChatInterface(this._service.ctx.root, {
       chatMode: room.chatMode,
       botName: config.botNames[0],

package/lib/utils/logger.cjs

@@ -68,21 +68,37 @@ async function trackLogToLocal(tag, output, logger) {
   if (!import_fs.default.existsSync(logDir)) {
     import_fs.default.mkdirSync(logDir, { recursive: true });
   }
-  await import_fs.default.promises.writeFile(logFile, output);
-  logger.info(`[${tag}] A local log file has been created at ${logFile}`);
-  const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1e3;
-  const files = await import_fs.default.promises.readdir(logDir);
-  for (const file of files) {
-    if (!file.startsWith("chatluna-log-") || !file.endsWith(".log")) {
-      continue;
+  const writeAndCleanup = /* @__PURE__ */ __name(async () => {
+    await import_fs.default.promises.writeFile(logFile, output);
+    logger.info(`[${tag}] A local log file has been created at ${logFile}`);
+    const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1e3;
+    const files = await import_fs.default.promises.readdir(logDir);
+    let deletedCount = 0;
+    for (const file of files) {
+      if (!file.startsWith("chatluna-log-") || !file.endsWith(".log")) {
+        continue;
+      }
+      const filePath = `${logDir}/${file}`;
+      let stats;
+      try {
+        stats = await import_fs.default.promises.stat(filePath);
+      } catch {
+        continue;
+      }
+      if (stats.mtimeMs < sevenDaysAgo) {
+        try {
+          await import_fs.default.promises.unlink(filePath);
+          deletedCount += 1;
+        } catch {
+        }
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      }
     }
-    const filePath = `${logDir}/${file}`;
-    const stats = await import_fs.default.promises.stat(filePath);
-    if (stats.mtimeMs < sevenDaysAgo) {
-      await import_fs.default.promises.unlink(filePath);
-      logger.debug(`[${tag}] Deleted old log file: ${filePath}`);
-    }
-  }
+    logger.debug(`[${tag}] Deleted ${deletedCount} old log file(s).`);
+  }, "writeAndCleanup");
+  setTimeout(() => {
+    writeAndCleanup().catch(() => void 0);
+  }, 0);
 }
 __name(trackLogToLocal, "trackLogToLocal");
 // Annotate the CommonJS export names for ESM import in node:

package/lib/utils/logger.mjs

@@ -34,21 +34,37 @@ async function trackLogToLocal(tag, output, logger) {
   if (!fs.existsSync(logDir)) {
     fs.mkdirSync(logDir, { recursive: true });
   }
-  await fs.promises.writeFile(logFile, output);
-  logger.info(`[${tag}] A local log file has been created at ${logFile}`);
-  const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1e3;
-  const files = await fs.promises.readdir(logDir);
-  for (const file of files) {
-    if (!file.startsWith("chatluna-log-") || !file.endsWith(".log")) {
-      continue;
+  const writeAndCleanup = /* @__PURE__ */ __name(async () => {
+    await fs.promises.writeFile(logFile, output);
+    logger.info(`[${tag}] A local log file has been created at ${logFile}`);
+    const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1e3;
+    const files = await fs.promises.readdir(logDir);
+    let deletedCount = 0;
+    for (const file of files) {
+      if (!file.startsWith("chatluna-log-") || !file.endsWith(".log")) {
+        continue;
+      }
+      const filePath = `${logDir}/${file}`;
+      let stats;
+      try {
+        stats = await fs.promises.stat(filePath);
+      } catch {
+        continue;
+      }
+      if (stats.mtimeMs < sevenDaysAgo) {
+        try {
+          await fs.promises.unlink(filePath);
+          deletedCount += 1;
+        } catch {
+        }
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      }
     }
-    const filePath = `${logDir}/${file}`;
-    const stats = await fs.promises.stat(filePath);
-    if (stats.mtimeMs < sevenDaysAgo) {
-      await fs.promises.unlink(filePath);
-      logger.debug(`[${tag}] Deleted old log file: ${filePath}`);
-    }
-  }
+    logger.debug(`[${tag}] Deleted ${deletedCount} old log file(s).`);
+  }, "writeAndCleanup");
+  setTimeout(() => {
+    writeAndCleanup().catch(() => void 0);
+  }, 0);
 }
 __name(trackLogToLocal, "trackLogToLocal");
 export {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-chatluna",
   "description": "chatluna for koishi",
-  "version": "1.3.13",
+  "version": "1.3.15",
   "main": "lib/index.cjs",
   "module": "lib/index.mjs",
   "typings": "lib/index.d.ts",