koishi-plugin-chatluna 1.3.34 → 1.3.35

package/lib/chains/chain.d.ts

@@ -46,7 +46,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 | h[] | h[][] | ChainMiddlewareRunStatus>;
+    run(session: Session, options: ChainMiddlewareContext): Promise<string | h[] | ChainMiddlewareRunStatus | h[][]>;
 }
 export interface ChainMiddlewareContext {
     config: Config;

package/lib/commands/conversation.d.ts

@@ -0,0 +1,33 @@
+import { Context } from 'koishi';
+import { Config } from '../config';
+import { ChatChain } from '../chains/chain';
+export declare function apply(ctx: Context, config: Config, chain: ChatChain): void;
+declare module '../chains/chain' {
+    interface ChainMiddlewareContextOptions {
+        conversation_create?: {
+            title?: string;
+            preset?: string;
+            model?: string;
+            chatMode?: string;
+        };
+        conversation_manage?: {
+            targetConversation?: string;
+            presetLane?: string;
+            includeArchived?: boolean;
+            title?: string;
+        };
+        conversation_use?: {
+            model?: string;
+            preset?: string;
+            chatMode?: string;
+        };
+        conversation_rule?: {
+            model?: string;
+            preset?: string;
+            chatMode?: string;
+            share?: string;
+            lock?: string;
+        };
+        i18n_base?: string;
+    }
+}

package/lib/legacy/types.d.ts

@@ -0,0 +1,29 @@
+export interface ConversationRoom {
+    visibility: 'public' | 'private' | 'template_clone';
+    roomMasterId: string;
+    roomName: string;
+    roomId: number;
+    conversationId?: string;
+    preset: string;
+    model: string;
+    chatMode: string;
+    password?: string;
+    autoUpdate?: boolean;
+    updatedTime: Date;
+}
+export interface ConversationRoomMemberInfo {
+    userId: string;
+    roomId: number;
+    mute?: boolean;
+    roomPermission: 'owner' | 'admin' | 'member';
+}
+export interface ConversationRoomGroupInfo {
+    groupId: string;
+    roomId: number;
+    roomVisibility: 'public' | 'private' | 'template_clone';
+}
+export interface ConversationRoomUserInfo {
+    groupId?: string;
+    defaultRoomId: number;
+    userId: string;
+}

package/lib/llm-core/agent/creator.d.ts

@@ -25,6 +25,7 @@ export interface CreateAgentExecutorOptions {
     tools: ComputedRef<StructuredTool[]>;
     prompt: ChatLunaChatPrompt;
     agentMode: 'react' | 'tool-calling';
+    maxIterations?: number;
     returnIntermediateSteps?: boolean;
     handleParsingErrors?: boolean;
     instructions?: ComputedRef<string>;

package/lib/llm-core/agent/index.cjs

@@ -1089,6 +1089,7 @@ function createAgentExecutor(options) {
     () => AgentExecutor.fromAgentAndTools({
       agent: cfg.value.agent,
       tools: cfg.value.tools,
+      maxIterations: options.maxIterations,
       returnIntermediateSteps: options.returnIntermediateSteps,
       handleParsingErrors: options.handleParsingErrors
     })

package/lib/llm-core/agent/index.mjs

@@ -1089,6 +1089,7 @@ function createAgentExecutor(options) {
     () => AgentExecutor.fromAgentAndTools({
       agent: cfg.value.agent,
       tools: cfg.value.tools,
+      maxIterations: options.maxIterations,
       returnIntermediateSteps: options.returnIntermediateSteps,
       handleParsingErrors: options.handleParsingErrors
     })

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

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

package/lib/llm-core/chat/helper.d.ts

@@ -1,4 +1,3 @@
-import { Embeddings } from '@langchain/core/embeddings';
 import { AIMessage } from '@langchain/core/messages';
 import { ComputedRef } from '@vue/reactivity';
 import { Context } from 'koishi';
@@ -6,7 +5,7 @@ import { ChatLunaChatModel } from 'koishi-plugin-chatluna/llm-core/platform/mode
 import { PlatformService } from 'koishi-plugin-chatluna/llm-core/platform/service';
 import { ModelInfo } from 'koishi-plugin-chatluna/llm-core/platform/types';
 export declare function createDisplayResponse(responseMessage: AIMessage): AIMessage;
-export declare function initEmbeddings(service: PlatformService, model: string | undefined): Promise<ComputedRef<Embeddings<number[]>>>;
+export declare function initEmbeddings(service: PlatformService, model: string | undefined): Promise<ComputedRef<import("koishi-plugin-chatluna/llm-core/model/in_memory").EmptyEmbeddings>>;
 export declare function initModel(ctx: Context, service: PlatformService, llmPlatform: string, llmModelName: string): Promise<[
     ComputedRef<ChatLunaChatModel>,
     ComputedRef<ModelInfo | undefined>

package/lib/middlewares/conversation/request_conversation.d.ts

@@ -0,0 +1,15 @@
+import { Context } from 'koishi';
+import { ChatChain } from 'koishi-plugin-chatluna/chains';
+import { Config } from '../../config';
+import { Message } from '../../types';
+export declare function apply(ctx: Context, config: Config, chain: ChatChain): void;
+declare module '../../chains/chain' {
+    interface ChainMiddlewareName {
+        request_conversation: never;
+    }
+    interface ChainMiddlewareContextOptions {
+        responseMessage?: Message;
+        inputMessage?: Message;
+        queueCount?: number;
+    }
+}

package/lib/middlewares/conversation/resolve_conversation.d.ts

@@ -0,0 +1,14 @@
+import { Context } from 'koishi';
+import { ChatChain } from '../../chains/chain';
+import { Config } from '../../config';
+import type { ConversationRecord, ResolvedConversationContext } from '../../services/conversation_types';
+export declare function apply(ctx: Context, config: Config, chain: ChatChain): void;
+declare module '../../chains/chain' {
+    interface ChainMiddlewareName {
+        resolve_conversation: never;
+    }
+    interface ChainMiddlewareContextOptions {
+        resolvedConversation?: ConversationRecord | null;
+        resolvedConversationContext?: ResolvedConversationContext;
+    }
+}

package/lib/middlewares/model/request_conversation.d.ts

@@ -0,0 +1,15 @@
+import { Context } from 'koishi';
+import { ChatChain } from 'koishi-plugin-chatluna/chains';
+import { Config } from '../../config';
+import { Message } from '../../types';
+export declare function apply(ctx: Context, config: Config, chain: ChatChain): void;
+declare module '../../chains/chain' {
+    interface ChainMiddlewareName {
+        request_conversation: never;
+    }
+    interface ChainMiddlewareContextOptions {
+        responseMessage?: Message;
+        inputMessage?: Message;
+        queueCount?: number;
+    }
+}

package/lib/middlewares/system/conversation_manage.d.ts

@@ -0,0 +1,27 @@
+import { Context } from 'koishi';
+import { ChatChain } from '../../chains/chain';
+import { Config } from '../../config';
+export declare function apply(ctx: Context, config: Config, chain: ChatChain): void;
+declare module '../../chains/chain' {
+    interface ChainMiddlewareName {
+        conversation_new: never;
+        conversation_switch: never;
+        conversation_list: never;
+        conversation_current: never;
+        conversation_rename: never;
+        conversation_delete: never;
+        conversation_use_model: never;
+        conversation_use_preset: never;
+        conversation_use_mode: never;
+        conversation_archive: never;
+        conversation_restore: never;
+        conversation_export: never;
+        conversation_compress: never;
+        conversation_rule_model: never;
+        conversation_rule_preset: never;
+        conversation_rule_mode: never;
+        conversation_rule_share: never;
+        conversation_rule_lock: never;
+        conversation_rule_show: never;
+    }
+}

package/lib/migration/legacy_tables.d.ts

@@ -0,0 +1,16 @@
+export declare const LEGACY_SCHEMA_SENTINEL = "data/chatluna/temp/legacy-schema-disabled.json";
+export declare const LEGACY_MIGRATION_TABLES: readonly ["chathub_room_member", "chathub_room_group_member", "chathub_user", "chathub_room", "chathub_message", "chathub_conversation"];
+export declare const LEGACY_RUNTIME_TABLES: readonly ["chathub_auth_group", "chathub_auth_joined_user", "chathub_auth_user"];
+export declare const LEGACY_RETENTION_META_KEY = "legacy_table_retention";
+export interface LegacyTableRetention {
+    state: 'migration-visible' | 'purged';
+    migrationTables: readonly string[];
+    runtimeTables: readonly string[];
+}
+export declare function createLegacyTableRetention(state: LegacyTableRetention['state']): {
+    state: "migration-visible" | "purged";
+    migrationTables: ("chathub_conversation" | "chathub_message" | "chathub_room" | "chathub_room_member" | "chathub_room_group_member" | "chathub_user")[];
+    runtimeTables: ("chathub_auth_group" | "chathub_auth_user" | "chathub_auth_joined_user")[];
+};
+export declare function getLegacySchemaSentinel(baseDir: string): string;
+export declare function getLegacySchemaSentinelDir(baseDir: string): string;

package/lib/migration/room_to_conversation.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from 'koishi';
+import type { Config } from '../config';
+export declare const BUILTIN_SCHEMA_VERSION = 1;
+export declare function runRoomToConversationMigration(ctx: Context, config: Config): any;
+export declare function ensureMigrationValidated(ctx: Context, config: Config): any;

package/lib/migration/validators.d.ts

@@ -0,0 +1,75 @@
+import type { Context } from 'koishi';
+import type { Config } from '../config';
+export { getLegacySchemaSentinelDir, getLegacySchemaSentinel, LEGACY_MIGRATION_TABLES, LEGACY_RETENTION_META_KEY, LEGACY_RUNTIME_TABLES, LEGACY_SCHEMA_SENTINEL, createLegacyTableRetention } from './legacy_tables';
+import type { LegacyRoomGroupRecord, LegacyRoomMemberRecord, LegacyRoomRecord, LegacyUserRecord } from '../services/types';
+export interface MigrationValidationResult {
+    passed: boolean;
+    checkedAt: string;
+    conversation: {
+        legacy: number;
+        migrated: number;
+        matched: boolean;
+    };
+    message: {
+        legacy: number;
+        migrated: number;
+        matched: boolean;
+    };
+    latestMessageId: {
+        missingConversationIds: string[];
+        matched: boolean;
+    };
+    bindingKey: {
+        inconsistentConversationIds: string[];
+        matched: boolean;
+    };
+    binding: {
+        missingBindingKeys: string[];
+        missingConversationIds: string[];
+        matched: boolean;
+    };
+    acl: {
+        expected: number;
+        migrated: number;
+        missing: string[];
+        matched: boolean;
+    };
+}
+export declare function validateRoomMigration(ctx: Context, config: Config): Promise<{
+    passed: boolean;
+    checkedAt: string;
+    conversation: {
+        legacy: number;
+        migrated: number;
+        matched: boolean;
+    };
+    message: {
+        legacy: number;
+        migrated: number;
+        matched: boolean;
+    };
+    latestMessageId: {
+        missingConversationIds: string[];
+        matched: boolean;
+    };
+    bindingKey: {
+        inconsistentConversationIds: string[];
+        matched: boolean;
+    };
+    binding: {
+        missingBindingKeys: string[];
+        missingConversationIds: string[];
+        matched: boolean;
+    };
+    acl: {
+        expected: number;
+        migrated: number;
+        missing: string[];
+        matched: boolean;
+    };
+}>;
+export declare function readMetaValue<T>(ctx: Context, key: string): Promise<T>;
+export declare function writeMetaValue(ctx: Context, key: string, value: unknown): Promise<void>;
+export declare function createLegacyBindingKey(user: LegacyUserRecord, routeModes: 'shared' | 'personal' | Map<string, 'shared' | 'personal'>): string;
+export declare function isComplexRoom(room: LegacyRoomRecord, members: LegacyRoomMemberRecord[], groups: LegacyRoomGroupRecord[]): boolean;
+export declare function inferLegacyGroupRouteModes(users: LegacyUserRecord[], rooms: LegacyRoomRecord[], groups: LegacyRoomGroupRecord[]): Map<string, "shared" | "personal">;

package/lib/services/conversation.d.ts

@@ -0,0 +1,101 @@
+import type { Session } from 'koishi';
+import type { Config } from '../config';
+import { ACLRecord, ArchiveRecord, BindingRecord, ConstraintRecord, ConversationRecord, MessageRecord, ConstraintPermission, ResolveConversationContextOptions, ResolvedConstraint, ResolvedConversationContext } from './conversation_types';
+interface ListConversationsOptions extends ResolveConversationContextOptions {
+    includeArchived?: boolean;
+}
+interface ResolveTargetConversationOptions extends ResolveConversationContextOptions {
+    targetConversation?: string;
+    includeArchived?: boolean;
+    permission?: ConstraintPermission;
+}
+export declare class ConversationService {
+    private readonly ctx;
+    private readonly config;
+    constructor(ctx: import('koishi').Context, config: Config);
+    getConversation(id: string): Promise<ConversationRecord>;
+    getBinding(bindingKey: string): Promise<BindingRecord>;
+    getArchive(id: string): Promise<ArchiveRecord>;
+    getArchiveByConversationId(conversationId: string): Promise<ArchiveRecord>;
+    listConstraints(): Promise<ConstraintRecord[]>;
+    matchConstraints(session: Session): Promise<ConstraintRecord[]>;
+    isConstraintMatched(constraint: ConstraintRecord, session: Session): boolean;
+    resolveConstraint(session: Session, options?: ResolveConversationContextOptions): Promise<ResolvedConstraint>;
+    resolveContext(session: Session, options?: ResolveConversationContextOptions): Promise<ResolvedConversationContext>;
+    private resolveBindingForKey;
+    ensureActiveConversation(session: Session, options?: ResolveConversationContextOptions): Promise<ResolvedConversationContext & {
+        conversation: ConversationRecord;
+    }>;
+    createConversation(session: Session, options: {
+        bindingKey: string;
+        title: string;
+        model: string;
+        preset: string;
+        chatMode: string;
+    }): Promise<ConversationRecord>;
+    setActiveConversation(bindingKey: string, conversationId: string): Promise<BindingRecord>;
+    touchConversation(conversationId: string, patch?: Partial<ConversationRecord>): Promise<ConversationRecord>;
+    listConversations(session: Session, options?: ListConversationsOptions): Promise<ConversationRecord[]>;
+    switchConversation(session: Session, options: ResolveTargetConversationOptions): Promise<ConversationRecord>;
+    getCurrentConversation(session: Session, options?: ResolveConversationContextOptions): Promise<ResolvedConversationContext>;
+    reopenConversation(session: Session, options: ResolveTargetConversationOptions): Promise<ConversationRecord>;
+    listMessages(conversationId: string): Promise<MessageRecord[]>;
+    listAcl(conversationId: string): Promise<ACLRecord[]>;
+    upsertAcl(conversationId: string, records: Omit<ACLRecord, 'conversationId'>[]): Promise<ACLRecord[]>;
+    replaceAcl(conversationId: string, records: Omit<ACLRecord, 'conversationId'>[]): Promise<ACLRecord[]>;
+    removeAcl(conversationId: string, records?: Partial<Omit<ACLRecord, 'conversationId'>>[]): Promise<ACLRecord[]>;
+    exportConversation(session: Session, options?: ResolveTargetConversationOptions & {
+        outputPath?: string;
+    }): Promise<{
+        conversation: ConversationRecord;
+        path: string;
+        size: number;
+        checksum: string;
+    }>;
+    archiveConversation(session: Session, options?: ResolveTargetConversationOptions): Promise<{
+        conversation: ConversationRecord;
+        archive: ArchiveRecord;
+        path: string;
+    }>;
+    archiveConversationById(conversationId: string): Promise<{
+        conversation: ConversationRecord;
+        archive: ArchiveRecord;
+        path: string;
+    }>;
+    restoreConversation(session: Session, options?: ResolveConversationContextOptions & {
+        archiveId?: string;
+    }): Promise<ConversationRecord>;
+    private buildArchivePayload;
+    exportMarkdown(conversation: ConversationRecord): Promise<string>;
+    renameConversation(session: Session, options: ResolveTargetConversationOptions & {
+        title: string;
+    }): Promise<ConversationRecord>;
+    deleteConversation(session: Session, options?: ResolveTargetConversationOptions): Promise<ConversationRecord>;
+    updateConversationUsage(session: Session, options: ResolveConversationContextOptions & {
+        model?: string;
+        preset?: string;
+        chatMode?: string;
+    }): Promise<ConversationRecord>;
+    recordCompression(conversationId: string, result: {
+        compressed: boolean;
+        inputTokens: number;
+        outputTokens: number;
+        reducedTokens: number;
+        reducedPercent: number;
+        originalMessageCount: number;
+        remainingMessageCount: number;
+    }): Promise<ConversationRecord>;
+    getManagedConstraint(session: Session): Promise<ConstraintRecord>;
+    updateManagedConstraint(session: Session, patch: Partial<ConstraintRecord>): Promise<ConstraintRecord>;
+    private getDefaultRouteMode;
+    private allocateConversationSeq;
+    resolveTargetConversation(session: Session, options?: ResolveTargetConversationOptions): Promise<ConversationRecord>;
+    private findAccessibleConversations;
+    resolveCommandConversation(session: Session, options?: ResolveTargetConversationOptions): Promise<ConversationRecord>;
+    private readArchivePayload;
+    private ensureDataDir;
+    private unbindConversation;
+    private assertManageAllowed;
+    private hasConversationPermission;
+}
+export {};

package/lib/services/conversation_runtime.d.ts

@@ -0,0 +1,61 @@
+import { BaseMessageChunk, HumanMessage } from '@langchain/core/messages';
+import type { Session } from 'koishi';
+import { LRUCache } from 'lru-cache';
+import type { ChatInterface } from '../llm-core/chat/app';
+import { type AgentAction, MessageQueue, type ToolMask } from '../llm-core/agent/types';
+import { RequestIdQueue } from '../utils/queue';
+import type { ChatLunaService } from './chat';
+import { ConversationRecord } from './conversation_types';
+import { Message } from '../types';
+import type { PostHandler } from '../utils/types';
+export interface ChatEvents {
+    'llm-new-token'?: (token: string) => Promise<void>;
+    'llm-queue-waiting'?: (size: number) => Promise<void>;
+    'llm-used-token-count'?: (token: number) => Promise<void>;
+    'llm-call-tool'?: (tool: string, args: any, content: AgentAction['content'], log: string) => Promise<void>;
+    'llm-new-chunk'?: (chunk: BaseMessageChunk) => Promise<void>;
+}
+export interface RuntimeConversationEntry {
+    conversation: ConversationRecord;
+    chatInterface: ChatInterface;
+}
+export interface ActiveRequest {
+    requestId: string;
+    conversationId: string;
+    sessionId?: string;
+    abortController: AbortController;
+    chatMode: string;
+    messageQueue: MessageQueue;
+    roundDecisionResolvers: ((canContinue: boolean) => void)[];
+    lastDecision?: boolean;
+}
+export declare class ConversationRuntime {
+    private readonly service;
+    readonly interfaces: LRUCache<string, RuntimeConversationEntry, unknown>;
+    readonly modelQueue: RequestIdQueue;
+    readonly conversationQueue: RequestIdQueue;
+    readonly requestsById: Map<string, AbortController>;
+    readonly activeByConversation: Map<string, ActiveRequest>;
+    readonly requestBySession: Map<string, string>;
+    readonly platformIndex: Map<string, Set<string>>;
+    constructor(service: ChatLunaService);
+    private get platformService();
+    ensureChatInterface(conversation: ConversationRecord): Promise<ChatInterface>;
+    chat(session: Session, conversation: ConversationRecord, message: Message, event: ChatEvents, stream?: boolean, variables?: Record<string, any>, postHandler?: PostHandler, requestId?: string, toolMask?: ToolMask): Promise<Message>;
+    updateConversationRecord(conversation: ConversationRecord): void;
+    getCachedConversations(): [string, RuntimeConversationEntry][];
+    withConversationLock<T>(conversationId: string, callback: () => Promise<T>): Promise<T>;
+    withConversationAndPlatformLock<T>(conversation: ConversationRecord, callback: () => Promise<T>): Promise<T>;
+    registerPlatformConversation(platform: string, conversationId: string): void;
+    unregisterPlatformConversation(platform: string, conversationId: string): void;
+    registerRequest(conversationId: string, requestId: string, chatMode: string, abortController: AbortController, session?: Session): ActiveRequest;
+    completeRequest(conversationId: string, requestId: string, session?: Session): void;
+    stopRequest(requestId: string): boolean;
+    getRequestIdBySession(session: Session): string;
+    appendPendingMessage(conversationId: string, message: HumanMessage, chatMode?: string): Promise<boolean>;
+    clearConversationCache(conversationId: string): Promise<boolean>;
+    clearConversationHistory(conversation: ConversationRecord): Promise<void>;
+    compressConversation(conversation: ConversationRecord, force?: boolean): Promise<import("../llm-core/chat/infinite_context").CompressContextResult>;
+    clearConversationInterface(conversation: ConversationRecord): Promise<boolean>;
+    dispose(platform?: string): void;
+}

package/lib/services/conversation_types.d.ts

@@ -0,0 +1,149 @@
+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;
+}
+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?: unknown;
+    additional_kwargs?: string | null;
+    additional_kwargs_binary?: ArrayBuffer | null;
+    rawId?: string | null;
+    createdAt?: Date | null;
+}
+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;
+    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[];
+    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 interface ResolveConversationContextOptions {
+    presetLane?: string;
+    conversationId?: string;
+}
+export declare function computeBaseBindingKey(session: Session, routeMode: RouteMode, routeKey?: string | null): string;
+export declare function applyPresetLane(bindingKey: string, presetLane?: string): string;

package/lib/utils/archive.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from 'koishi';
+export declare function purgeArchivedConversation(ctx: Context, conversation: {
+    id: string;
+    archiveId?: string | null;
+}): Promise<void>;

package/lib/utils/chat_request.d.ts

@@ -0,0 +1,4 @@
+import type { Session } from 'koishi';
+export declare function getRequestId(session: Session, conversationId: string): string;
+export declare function createRequestId(session: Session, conversationId: string, requestId?: string): string;
+export declare function deleteRequestId(session: Session, conversationId: string): void;

package/lib/utils/compression.d.ts

@@ -0,0 +1,6 @@
+type Encoding = 'buffer' | 'base64' | 'hex';
+type BufferType<T extends Encoding> = T extends 'buffer' ? Buffer : T extends 'base64' ? string : T extends 'hex' ? string : never;
+export declare function gzipEncode<T extends Encoding = 'buffer'>(data: string, encoding?: T): Promise<BufferType<T>>;
+export declare function gzipDecode(data: ArrayBuffer | ArrayBufferView): Promise<string>;
+export declare function bufferToArrayBuffer(buffer: Buffer): ArrayBuffer;
+export {};

package/lib/utils/message_content.d.ts

@@ -0,0 +1,8 @@
+import { type BaseMessage } from '@langchain/core/messages';
+export interface PresetLaneParseResult {
+    preset?: string;
+    content?: string;
+    queryOnly: boolean;
+}
+export declare function getMessageContent(message: BaseMessage['content']): string;
+export declare function parsePresetLaneInput(text: string, aliases: string[]): PresetLaneParseResult | null;

package/lib/utils/model.d.ts

@@ -0,0 +1 @@
+export declare function parseRawModelName(modelName: string): [string, string];

package/package.json

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