koishi-plugin-chatluna 1.4.0-alpha.9 → 1.4.0

package/lib/chains/chain.d.ts

@@ -1,9 +1,7 @@
 import { Context, h, Session } from 'koishi';
 import { Config } from '../config';
-import type { ConversationResolution } from '../services/conversation_types';
+import type { ChatInvocationContext, ConversationResolution } from '../types';
 import '../middlewares/system/lifecycle';
-import type { UsageMetadata } from '@langchain/core/messages';
-import type { ToolMask } from '../llm-core/agent';
 export declare class ChatChain {
     private readonly ctx;
     private readonly config;
@@ -14,6 +12,10 @@ export declare class ChatChain {
     private _createRecallThinkingMessage;
     receiveMessage(session: Session, ctx?: Context): Promise<boolean>;
     receiveCommand(session: Session, command: string, options?: ChainMiddlewareContextOptions, ctx?: Context): Promise<boolean>;
+    runCommand(session: Session, command: string, options?: ChainMiddlewareContextOptions, ctx?: Context): Promise<{
+        ok: boolean;
+        context: ChainMiddlewareContext;
+    }>;
     middleware<T extends keyof ChainMiddlewareName>(name: T, middleware: ChainMiddlewareFunction, ctx?: Context): ChainMiddleware;
     sender(sender: ChatChainSender): void;
     private _runMiddleware;
@@ -48,7 +50,7 @@ export declare class ChainMiddleware {
     constructor(name: string, execute: ChainMiddlewareFunction, graph: ChatChainDependencyGraph);
     before<T extends keyof ChainMiddlewareName>(name: T): this;
     after<T extends keyof ChainMiddlewareName>(name: T): this;
-    run(session: Session, options: ChainMiddlewareContext): Promise<string | ChainMiddlewareRunStatus | h[] | h[][]>;
+    run(session: Session, options: ChainMiddlewareContext): Promise<string | h[] | ChainMiddlewareRunStatus | h[][]>;
 }
 export interface ChainMiddlewareContext {
     config: Config;
@@ -60,26 +62,12 @@ export interface ChainMiddlewareContext {
     recallThinkingMessage?: () => Promise<void>;
     send: (message: h[][] | h[] | h | string) => Promise<void>;
 }
-export interface TriggerWakeupContext {
-    requestId: string;
-    replyTo?: 'channel' | 'user' | 'silent' | 'callback';
-    source: {
-        kind: string;
-        taskId?: number;
-        providerKind?: string;
-        detail?: unknown;
-    };
-    chatMode?: string;
-    signal?: AbortSignal;
-    toolMask?: ToolMask;
-    variables?: Record<string, unknown>;
-    state?: {
-        tokens?: UsageMetadata;
-    };
-}
 export interface ChainMiddlewareContextOptions {
     conversation?: ConversationResolution;
-    triggerWakeup?: TriggerWakeupContext;
+    invocation?: ChatInvocationContext;
+    deliverySession?: Session;
+    messageName?: string;
+    error?: Error;
     [key: string]: any;
 }
 export interface ChainMiddlewareName {

package/lib/chains/index.cjs

@@ -74,6 +74,8 @@ var ChatChain = class {
       (session, messages, context) => defaultChatChainSender.send(session, messages, context)
     );
   }
+  ctx;
+  config;
   static {
     __name(this, "ChatChain");
   }
@@ -86,6 +88,7 @@ var ChatChain = class {
       const timeoutObj = context.options.thinkingTimeoutObject;
       clearTimeout(timeoutObj.timeout);
       timeoutObj.autoRecallTimeout && clearTimeout(timeoutObj.autoRecallTimeout);
+      timeoutObj.setQueueCount(0);
       timeoutObj.recallFunc && await timeoutObj.recallFunc();
       timeoutObj.timeout = null;
       context.options.thinkingTimeoutObject = void 0;
@@ -106,18 +109,33 @@ var ChatChain = class {
       )
     };
     context.recallThinkingMessage = this._createRecallThinkingMessage(context);
-    const result = await this._runMiddleware(session, context);
-    await context.recallThinkingMessage();
-    return result;
+    try {
+      return await this._runMiddleware(session, context);
+    } finally {
+      await context.options.completeMessageTurn?.();
+      await context.recallThinkingMessage();
+    }
   }
   async receiveCommand(session, command, options = {}, ctx = this.ctx) {
+    return (await this.runCommand(session, command, options, ctx)).ok;
+  }
+  async runCommand(session, command, options = {}, ctx = this.ctx) {
     const context = {
       config: this.config,
       message: options?.message ?? session.content,
       ctx,
       session,
       command,
-      send: /* @__PURE__ */ __name((message) => this.sendMessage(session, message, context), "send"),
+      send: /* @__PURE__ */ __name(async (message) => {
+        if (options.invocation?.delivery === "silent" || options.invocation?.delivery === "capture") {
+          return;
+        }
+        await this.sendMessage(
+          options.deliverySession ?? session,
+          message,
+          context
+        );
+      }, "send"),
       recallThinkingMessage: this._createRecallThinkingMessage(
         {}
       ),
@@ -127,9 +145,13 @@ var ChatChain = class {
       }
     };
     context.recallThinkingMessage = this._createRecallThinkingMessage(context);
-    const result = await this._runMiddleware(session, context);
-    await context.recallThinkingMessage();
-    return result;
+    try {
+      const ok = await this._runMiddleware(session, context);
+      return { ok, context };
+    } finally {
+      await context.options.completeMessageTurn?.();
+      await context.recallThinkingMessage();
+    }
   }
   middleware(name, middleware, ctx = this.ctx) {
     const result = new ChainMiddleware(name, middleware, this._graph);
@@ -165,8 +187,10 @@ var ChatChain = class {
           return false;
         }
         if (result.status === "error") {
+          context.options.error = result.error;
           await this._handleMiddlewareError(
             session,
+            context,
             result.middlewareName,
             result.error
           );
@@ -184,7 +208,7 @@ var ChatChain = class {
       logger.debug("-".repeat(40) + "\n");
     }
     if (context.message != null && context.message !== originMessage) {
-      await this.sendMessage(session, context.message, context);
+      await context.send(context.message);
     }
     return true;
   }
@@ -253,7 +277,7 @@ var ChatChain = class {
       const shouldLogTime = !middleware.name.startsWith("lifecycle-") && result !== 0 /* SKIPPED */ && middleware.name !== "allow_reply" && executionTime > 100;
       if (shouldLogTime) {
         logger.debug(
-          `middleware %c executed in %s`,
+          `[Middleware] %c completed in %c`,
           middleware.name,
           formatDuration(executionTime)
         );
@@ -288,29 +312,28 @@ var ChatChain = class {
   }
   async _handleStopStatus(session, context, originMessage, isOutputLog) {
     if (context.message != null && context.message !== originMessage) {
-      await this.sendMessage(session, context.message, context);
+      await context.send(context.message);
     }
     if (isOutputLog) {
       logger.debug("-".repeat(40) + "\n");
     }
   }
-  async _handleMiddlewareError(session, middlewareName, error) {
+  async _handleMiddlewareError(session, context, middlewareName, error) {
+    if (context.options.invocation != null) return;
     if (error instanceof import_error.ChatLunaError) {
       const message = error.errorCode === import_error.ChatLunaErrorCode.ABORTED ? session.text("chatluna.aborted") : error.message;
-      await this.sendMessage(session, message, void 0);
+      await context.send(message);
       return;
     }
     logger.error(`chat-chain: ${middlewareName} error ${error}`);
     logger.error(error);
     error.cause && logger.error(error.cause);
     logger.debug("-".repeat(40) + "\n");
-    await this.sendMessage(
-      session,
+    await context.send(
       session.text("chatluna.middleware_error", [
         middlewareName,
         error.message
-      ]),
-      void 0
+      ])
     );
   }
 };
@@ -720,6 +743,9 @@ var ChainMiddleware = class {
     this.execute = execute;
     this.graph = graph;
   }
+  name;
+  execute;
+  graph;
   static {
     __name(this, "ChainMiddleware");
   }
@@ -739,6 +765,7 @@ var DefaultChatChainSender = class {
   constructor(config) {
     this.config = config;
   }
+  config;
   static {
     __name(this, "DefaultChatChainSender");
   }
@@ -771,17 +798,14 @@ var DefaultChatChainSender = class {
   }
   async sendAsQQMarkdown(session, message) {
     const { user } = session.event;
-    await session.bot.internal.sendPrivateMessage(
-      user.id,
-      {
-        msg_type: 2,
-        msg_seq: 1,
-        msg_id: session.messageId,
-        markdown: {
-          content: message.attrs["content"]
-        }
+    await session["bot"].internal.sendPrivateMessage(user.id, {
+      msg_type: 2,
+      msg_seq: 1,
+      msg_id: session.messageId,
+      markdown: {
+        content: message.attrs["content"]
       }
-    );
+    });
   }
   async sendAsForward(session, messages) {
     const sendMessages = this.convertToForwardMessages(messages);

package/lib/chains/index.mjs

@@ -53,6 +53,8 @@ var ChatChain = class {
       (session, messages, context) => defaultChatChainSender.send(session, messages, context)
     );
   }
+  ctx;
+  config;
   static {
     __name(this, "ChatChain");
   }
@@ -65,6 +67,7 @@ var ChatChain = class {
       const timeoutObj = context.options.thinkingTimeoutObject;
       clearTimeout(timeoutObj.timeout);
       timeoutObj.autoRecallTimeout && clearTimeout(timeoutObj.autoRecallTimeout);
+      timeoutObj.setQueueCount(0);
       timeoutObj.recallFunc && await timeoutObj.recallFunc();
       timeoutObj.timeout = null;
       context.options.thinkingTimeoutObject = void 0;
@@ -85,18 +88,33 @@ var ChatChain = class {
       )
     };
     context.recallThinkingMessage = this._createRecallThinkingMessage(context);
-    const result = await this._runMiddleware(session, context);
-    await context.recallThinkingMessage();
-    return result;
+    try {
+      return await this._runMiddleware(session, context);
+    } finally {
+      await context.options.completeMessageTurn?.();
+      await context.recallThinkingMessage();
+    }
   }
   async receiveCommand(session, command, options = {}, ctx = this.ctx) {
+    return (await this.runCommand(session, command, options, ctx)).ok;
+  }
+  async runCommand(session, command, options = {}, ctx = this.ctx) {
     const context = {
       config: this.config,
       message: options?.message ?? session.content,
       ctx,
       session,
       command,
-      send: /* @__PURE__ */ __name((message) => this.sendMessage(session, message, context), "send"),
+      send: /* @__PURE__ */ __name(async (message) => {
+        if (options.invocation?.delivery === "silent" || options.invocation?.delivery === "capture") {
+          return;
+        }
+        await this.sendMessage(
+          options.deliverySession ?? session,
+          message,
+          context
+        );
+      }, "send"),
       recallThinkingMessage: this._createRecallThinkingMessage(
         {}
       ),
@@ -106,9 +124,13 @@ var ChatChain = class {
       }
     };
     context.recallThinkingMessage = this._createRecallThinkingMessage(context);
-    const result = await this._runMiddleware(session, context);
-    await context.recallThinkingMessage();
-    return result;
+    try {
+      const ok = await this._runMiddleware(session, context);
+      return { ok, context };
+    } finally {
+      await context.options.completeMessageTurn?.();
+      await context.recallThinkingMessage();
+    }
   }
   middleware(name, middleware, ctx = this.ctx) {
     const result = new ChainMiddleware(name, middleware, this._graph);
@@ -144,8 +166,10 @@ var ChatChain = class {
           return false;
         }
         if (result.status === "error") {
+          context.options.error = result.error;
           await this._handleMiddlewareError(
             session,
+            context,
             result.middlewareName,
             result.error
           );
@@ -163,7 +187,7 @@ var ChatChain = class {
       logger.debug("-".repeat(40) + "\n");
     }
     if (context.message != null && context.message !== originMessage) {
-      await this.sendMessage(session, context.message, context);
+      await context.send(context.message);
     }
     return true;
   }
@@ -232,7 +256,7 @@ var ChatChain = class {
       const shouldLogTime = !middleware.name.startsWith("lifecycle-") && result !== 0 /* SKIPPED */ && middleware.name !== "allow_reply" && executionTime > 100;
       if (shouldLogTime) {
         logger.debug(
-          `middleware %c executed in %s`,
+          `[Middleware] %c completed in %c`,
           middleware.name,
           formatDuration(executionTime)
         );
@@ -267,29 +291,28 @@ var ChatChain = class {
   }
   async _handleStopStatus(session, context, originMessage, isOutputLog) {
     if (context.message != null && context.message !== originMessage) {
-      await this.sendMessage(session, context.message, context);
+      await context.send(context.message);
     }
     if (isOutputLog) {
       logger.debug("-".repeat(40) + "\n");
     }
   }
-  async _handleMiddlewareError(session, middlewareName, error) {
+  async _handleMiddlewareError(session, context, middlewareName, error) {
+    if (context.options.invocation != null) return;
     if (error instanceof ChatLunaError) {
       const message = error.errorCode === ChatLunaErrorCode.ABORTED ? session.text("chatluna.aborted") : error.message;
-      await this.sendMessage(session, message, void 0);
+      await context.send(message);
       return;
     }
     logger.error(`chat-chain: ${middlewareName} error ${error}`);
     logger.error(error);
     error.cause && logger.error(error.cause);
     logger.debug("-".repeat(40) + "\n");
-    await this.sendMessage(
-      session,
+    await context.send(
       session.text("chatluna.middleware_error", [
         middlewareName,
         error.message
-      ]),
-      void 0
+      ])
     );
   }
 };
@@ -699,6 +722,9 @@ var ChainMiddleware = class {
     this.execute = execute;
     this.graph = graph;
   }
+  name;
+  execute;
+  graph;
   static {
     __name(this, "ChainMiddleware");
   }
@@ -718,6 +744,7 @@ var DefaultChatChainSender = class {
   constructor(config) {
     this.config = config;
   }
+  config;
   static {
     __name(this, "DefaultChatChainSender");
   }
@@ -750,17 +777,14 @@ var DefaultChatChainSender = class {
   }
   async sendAsQQMarkdown(session, message) {
     const { user } = session.event;
-    await session.bot.internal.sendPrivateMessage(
-      user.id,
-      {
-        msg_type: 2,
-        msg_seq: 1,
-        msg_id: session.messageId,
-        markdown: {
-          content: message.attrs["content"]
-        }
+    await session["bot"].internal.sendPrivateMessage(user.id, {
+      msg_type: 2,
+      msg_seq: 1,
+      msg_id: session.messageId,
+      markdown: {
+        content: message.attrs["content"]
       }
-    );
+    });
   }
   async sendAsForward(session, messages) {
     const sendMessages = this.convertToForwardMessages(messages);

package/lib/commands/conversation.d.ts

@@ -18,6 +18,7 @@ declare module '../chains/chain' {
         };
         conversation_use?: {
             model?: string;
+            auto?: boolean;
             preset?: string;
             chatMode?: string;
         };
@@ -30,6 +31,10 @@ declare module '../chains/chain' {
             force?: boolean;
             newOnly?: boolean;
             clear?: boolean;
+            auto?: boolean;
+        };
+        conversation_compress?: {
+            instruction?: string;
         };
         i18n_base?: string;
     }

package/lib/config.d.ts

@@ -10,6 +10,7 @@ export interface Config {
     randomReplyFrequency: Computed<Awaitable<number>>;
     includeQuoteReply: boolean;
     attachForwardMsgIdToContext: boolean;
+    autoUpdateConversationModel: boolean;
     isLog: boolean;
     isReplyWithAt: boolean;
     replyQuoteThreshold?: number;
@@ -20,7 +21,7 @@ export interface Config {
     sendThinkingMessage: boolean;
     sendThinkingMessageTimeout: number;
     showThoughtMessage: boolean;
-    splitMessage: boolean;
+    splitMessage: 'none' | 'punctuation' | 'paragraph';
     blackList: Computed<Awaitable<number>>;
     censor: boolean;
     autoArchive: boolean;
@@ -29,6 +30,7 @@ export interface Config {
     autoPurgeArchiveTimeout: number;
     messageQueue: boolean;
     messageQueueDelay: number;
+    agentTaskAutoWakeup: boolean;
     infiniteContext: boolean;
     infiniteContextThreshold: number;
     rawOnCensor: boolean;
@@ -41,6 +43,7 @@ export interface Config {
     defaultChatMode: string;
     defaultModel: string;
     defaultPreset: string;
+    enablePresetKeywordTrigger: boolean;
     voiceSpeakId: number;
     enableSimilarityCheck: boolean;
 }

package/lib/conversation_types.d.ts

@@ -0,0 +1,206 @@
+import { AIMessage } from '@langchain/core/messages';
+import type { Session } from 'koishi';
+export type ConversationStatus = 'active' | 'archived' | 'deleted' | 'broken';
+export type RouteMode = 'personal' | 'shared' | 'custom';
+export type ConstraintManageMode = 'anyone' | 'admin';
+export type ConstraintPrincipalType = 'user' | 'guild';
+export type ConstraintPermission = 'view' | 'manage';
+export type ArchiveState = 'ready' | 'restoring' | 'broken';
+export interface ConversationCompressionRecord {
+    count?: number;
+    summary?: string;
+    compressedAt?: Date | string | null;
+    originalMessageCount?: number;
+    remainingMessageCount?: number;
+    tokenUsage?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    reducedTokens?: number;
+    reducedPercent?: number;
+    [key: string]: unknown;
+}
+export interface ConversationRecord {
+    id: string;
+    seq?: number;
+    bindingKey: string;
+    title: string;
+    model: string;
+    preset: string;
+    chatMode: string;
+    createdBy: string;
+    createdAt: Date;
+    updatedAt: Date;
+    lastChatAt?: Date | null;
+    status: ConversationStatus;
+    latestMessageId?: string | null;
+    additional_kwargs?: string | null;
+    compression?: string | null;
+    archivedAt?: Date | null;
+    archiveId?: string | null;
+    legacyRoomId?: number | null;
+    legacyMeta?: string | null;
+    autoTitle?: boolean | null;
+}
+export interface ConversationListEntry {
+    conversation: ConversationRecord;
+    displaySeq: number;
+}
+export interface MessageRecord {
+    id: string;
+    conversationId: string;
+    parentId?: string | null;
+    role: string;
+    text?: string | null;
+    content?: ArrayBuffer | null;
+    name?: string | null;
+    tool_call_id?: string | null;
+    tool_calls?: AIMessage['tool_calls'];
+    additional_kwargs_binary?: ArrayBuffer | null;
+    response_metadata_binary?: ArrayBuffer | null;
+    rawId?: string | null;
+    createdAt?: Date | null;
+}
+export interface ChatLunaMessageMeta {
+    recordId?: string;
+    createdAt?: string;
+    source?: 'user';
+}
+export interface BindingRecord {
+    bindingKey: string;
+    activeConversationId?: string | null;
+    lastConversationId?: string | null;
+    updatedAt: Date;
+}
+export interface ConstraintRecord {
+    id?: number;
+    name: string;
+    enabled: boolean;
+    priority: number;
+    createdBy: string;
+    createdAt: Date;
+    updatedAt: Date;
+    platform?: string | null;
+    selfId?: string | null;
+    guildId?: string | null;
+    channelId?: string | null;
+    direct?: boolean | null;
+    users?: string | null;
+    excludeUsers?: string | null;
+    routeMode?: RouteMode | null;
+    routeKey?: string | null;
+    activePresetLane?: string | null;
+    defaultModel?: string | null;
+    defaultPreset?: string | null;
+    defaultChatMode?: string | null;
+    fixedModel?: string | null;
+    fixedPreset?: string | null;
+    fixedChatMode?: string | null;
+    lockConversation?: boolean | null;
+    allowNew?: boolean | null;
+    allowSwitch?: boolean | null;
+    allowArchive?: boolean | null;
+    allowExport?: boolean | null;
+    manageMode?: ConstraintManageMode | null;
+}
+export interface ArchiveRecord {
+    id: string;
+    conversationId: string;
+    path: string;
+    formatVersion: number;
+    messageCount: number;
+    checksum?: string | null;
+    size: number;
+    state: ArchiveState;
+    createdAt: Date;
+    restoredAt?: Date | null;
+}
+export interface ACLRecord {
+    conversationId: string;
+    principalType: ConstraintPrincipalType;
+    principalId: string;
+    permission: ConstraintPermission;
+}
+export interface MetaRecord {
+    key: string;
+    value?: string | null;
+    updatedAt: Date;
+}
+export interface ResolvedConstraint {
+    routeMode: RouteMode;
+    bindingKey: string;
+    baseKey: string;
+    constraints: ConstraintRecord[];
+    activePresetLane?: string | null;
+    defaultModel?: string | null;
+    defaultPreset?: string | null;
+    defaultChatMode?: string | null;
+    fixedModel?: string | null;
+    fixedPreset?: string | null;
+    fixedChatMode?: string | null;
+    lockConversation: boolean;
+    allowNew: boolean;
+    allowSwitch: boolean;
+    allowArchive: boolean;
+    allowExport: boolean;
+    manageMode: ConstraintManageMode;
+}
+export interface ResolvedConversationContext {
+    bindingKey: string;
+    presetLane?: string;
+    conversation?: ConversationRecord | null;
+    binding?: BindingRecord | null;
+    effectiveModel?: string | null;
+    effectivePreset?: string | null;
+    effectiveChatMode?: string | null;
+    constraint: ResolvedConstraint;
+}
+export type ConversationResolveMode = 'context' | 'active' | 'target';
+export type ConversationResolutionErrorCode = 'ambiguous_target' | 'target_outside_route';
+export declare class ConversationResolutionError extends Error {
+    readonly code: ConversationResolutionErrorCode;
+    constructor(code: ConversationResolutionErrorCode);
+}
+export declare class ConversationNotFoundError extends Error {
+    constructor();
+}
+export type ConstraintAction = 'create' | 'switch' | 'rename' | 'delete' | 'archive' | 'restore' | 'export' | 'update' | 'compress';
+export declare class ConstraintLockedError extends Error {
+    readonly action: ConstraintAction;
+    constructor(action: ConstraintAction);
+}
+export declare class ConstraintDisabledError extends Error {
+    readonly action: ConstraintAction;
+    constructor(action: ConstraintAction);
+}
+export type ConstraintFixedField = 'model' | 'preset' | 'chatMode';
+export declare class ConstraintFixedError extends Error {
+    readonly field: ConstraintFixedField;
+    readonly value: string;
+    constructor(field: ConstraintFixedField, value: string);
+}
+export declare class InvalidChatModeError extends Error {
+    readonly mode: string;
+    constructor(mode: string);
+}
+export declare class AdminRequiredError extends Error {
+    constructor();
+}
+export interface ResolveConversationOptions {
+    mode?: ConversationResolveMode;
+    presetLane?: string;
+    conversationId?: string;
+    bindingKey?: string;
+    useRoutePresetLane?: boolean;
+    targetConversation?: string;
+    includeArchived?: boolean;
+    permission?: ConstraintPermission;
+    allPresetLanes?: boolean;
+}
+export interface ConversationResolution extends ResolvedConversationContext {
+    mode: ConversationResolveMode;
+    conversationId: string | null;
+}
+export declare function getBaseBindingKey(bindingKey: string): string;
+export declare function getPresetLane(bindingKey: string): string;
+export declare function computeBaseBindingKey(session: Session, routeMode: RouteMode, routeKey?: string | null): string;
+export declare function applyPresetLane(bindingKey: string, presetLane?: string): string;