koishi-plugin-chatluna 1.3.34 → 1.3.36

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/index.cjs

@@ -1124,7 +1124,7 @@ var ChatLunaPluginChain = class _ChatLunaPluginChain extends import_base2.ChatLu
   static {
     __name(this, "ChatLunaPluginChain");
   }
-  executor;
+  runner;
   historyMemory;
   systemPrompts;
   llm;
@@ -1163,7 +1163,7 @@ var ChatLunaPluginChain = class _ChatLunaPluginChain extends import_base2.ChatLu
       embeddings: this.embeddings,
       toolMask: this.toolMask
     });
-    this.executor = this._createExecutor();
+    this.runner = this._createRunner();
   }
   static fromLLMAndTools(llm, tools, {
     historyMemory,
@@ -1194,8 +1194,8 @@ var ChatLunaPluginChain = class _ChatLunaPluginChain extends import_base2.ChatLu
       toolMask
     });
   }
-  _createExecutor() {
-    return (0, import_agent.createAgentExecutor)({
+  _createRunner() {
+    return (0, import_agent.createAgentRunner)({
       llm: (0, import_reactivity.computed)(() => this.llm),
       tools: this._toolsRef.tools,
       prompt: this.prompt,
@@ -1253,12 +1253,17 @@ var ChatLunaPluginChain = class _ChatLunaPluginChain extends import_base2.ChatLu
     };
     this._toolsRef.update(session, messages.concat(message), toolMask);
     const preset = this.preset.value;
-    const executor = this.executor.value;
+    const runner = this.runner.value.withConfig({
+      configurable: {
+        messageQueue,
+        onAgentEvent
+      }
+    });
     let usedToken = 0;
     let response;
     let error;
     const request2 = /* @__PURE__ */ __name(() => {
-      return executor.invoke(
+      return runner.invoke(
         {
           ...requests,
           maxTokens: maxToken
@@ -1301,8 +1306,6 @@ var ChatLunaPluginChain = class _ChatLunaPluginChain extends import_base2.ChatLu
             preset: preset.triggerKeyword[0],
             userId: session.userId,
             toolMask,
-            messageQueue,
-            onAgentEvent,
             subagentContext
           }
         }

package/lib/index.mjs

@@ -1092,7 +1092,7 @@ import {
   ChatLunaLLMChainWrapper as ChatLunaLLMChainWrapper2
 } from "koishi-plugin-chatluna/llm-core/chain/base";
 import {
-  createAgentExecutor,
+  createAgentRunner,
   createToolsRef
 } from "koishi-plugin-chatluna/llm-core/agent";
 import { logger } from "koishi-plugin-chatluna";
@@ -1110,7 +1110,7 @@ var ChatLunaPluginChain = class _ChatLunaPluginChain extends ChatLunaLLMChainWra
   static {
     __name(this, "ChatLunaPluginChain");
   }
-  executor;
+  runner;
   historyMemory;
   systemPrompts;
   llm;
@@ -1149,7 +1149,7 @@ var ChatLunaPluginChain = class _ChatLunaPluginChain extends ChatLunaLLMChainWra
       embeddings: this.embeddings,
       toolMask: this.toolMask
     });
-    this.executor = this._createExecutor();
+    this.runner = this._createRunner();
   }
   static fromLLMAndTools(llm, tools, {
     historyMemory,
@@ -1180,8 +1180,8 @@ var ChatLunaPluginChain = class _ChatLunaPluginChain extends ChatLunaLLMChainWra
       toolMask
     });
   }
-  _createExecutor() {
-    return createAgentExecutor({
+  _createRunner() {
+    return createAgentRunner({
       llm: computed(() => this.llm),
       tools: this._toolsRef.tools,
       prompt: this.prompt,
@@ -1239,12 +1239,17 @@ var ChatLunaPluginChain = class _ChatLunaPluginChain extends ChatLunaLLMChainWra
     };
     this._toolsRef.update(session, messages.concat(message), toolMask);
     const preset = this.preset.value;
-    const executor = this.executor.value;
+    const runner = this.runner.value.withConfig({
+      configurable: {
+        messageQueue,
+        onAgentEvent
+      }
+    });
     let usedToken = 0;
     let response;
     let error;
     const request2 = /* @__PURE__ */ __name(() => {
-      return executor.invoke(
+      return runner.invoke(
         {
           ...requests,
           maxTokens: maxToken
@@ -1287,8 +1292,6 @@ var ChatLunaPluginChain = class _ChatLunaPluginChain extends ChatLunaLLMChainWra
             preset: preset.triggerKeyword[0],
             userId: session.userId,
             toolMask,
-            messageQueue,
-            onAgentEvent,
             subagentContext
           }
         }

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/agent.d.ts

@@ -0,0 +1,65 @@
+import { BaseMessage, BaseMessageChunk, HumanMessage } from '@langchain/core/messages';
+import { StructuredTool } from '@langchain/core/tools';
+import { type ComputedRef } from '@vue/reactivity';
+import { type Session } from 'koishi';
+import { z } from 'zod';
+import type { ChatLunaChatPrompt } from '../chain/prompt';
+import type { ChatLunaBaseEmbeddings, ChatLunaChatModel } from 'koishi-plugin-chatluna/llm-core/platform/model';
+import type { ChatLunaTool } from 'koishi-plugin-chatluna/llm-core/platform/types';
+import type { PresetTemplate } from '../prompt';
+import type { AgentRunnerOutput } from './executor';
+import type { AgentEvent, MessageQueue, SubagentContext, ToolMask } from './types';
+export interface CreateAgentOptions {
+    id?: string;
+    name?: string;
+    description?: string;
+    llm: ComputedRef<ChatLunaChatModel>;
+    embeddings: ChatLunaBaseEmbeddings;
+    tools: ComputedRef<ChatLunaTool[]>;
+    prompt: ChatLunaChatPrompt;
+    mode?: 'tool-calling' | 'react';
+    maxSteps?: number;
+    handleParsingErrors?: boolean | string | ((e: Error) => string);
+    instructions?: ComputedRef<string | undefined>;
+    returnIntermediateSteps?: boolean;
+    toolMask?: ToolMask;
+}
+export interface AgentGenerateOptions {
+    prompt: string | HumanMessage;
+    session?: Session;
+    conversationId?: string;
+    history?: BaseMessage[];
+    variables?: Record<string, any>;
+    signal?: AbortSignal;
+    maxToken?: number;
+    messageQueue?: MessageQueue;
+    toolMask?: ToolMask;
+    subagentContext?: SubagentContext;
+    source?: 'chatluna' | 'character';
+    onStep?: (event: AgentEvent) => Promise<void> | void;
+    onToken?: (token: string) => Promise<void> | void;
+    onChunk?: (chunk: BaseMessageChunk) => Promise<void> | void;
+}
+export interface AgentStream {
+    text: AsyncIterable<string>;
+    steps: AsyncIterable<AgentEvent>;
+    result: Promise<AgentRunnerOutput>;
+}
+export interface AgentToolOptions {
+    name?: string;
+    description?: string;
+}
+export interface ChatLunaAgent {
+    id: string;
+    name: string;
+    description: string;
+    generate(input: AgentGenerateOptions): Promise<AgentRunnerOutput>;
+    stream(input: AgentGenerateOptions): Promise<AgentStream>;
+    asTool(options?: AgentToolOptions): StructuredTool;
+}
+export interface CreateAgentToolOptions extends AgentToolOptions {
+    schema?: z.ZodTypeAny;
+}
+export declare function createAgent(options: CreateAgentOptions): ChatLunaAgent;
+export declare function createAgentTool(agent: ChatLunaAgent, options?: CreateAgentToolOptions): StructuredTool;
+export declare function createPromptPreset(name: string, system?: string, preset?: ComputedRef<PresetTemplate>): ComputedRef<PresetTemplate>;

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

@@ -6,31 +6,34 @@ import { ChatLunaTool } from '../platform/types';
 import { BaseMessage } from '@langchain/core/messages';
 import { Session } from 'koishi';
 import type { Runnable } from '@langchain/core/runnables';
-import { AgentExecutor } from './executor';
+import { AgentRunner } from './executor';
 import { ToolMask } from './types';
 export interface CreateAgentConfigOptions {
     llm: ComputedRef<ChatLunaChatModel>;
     tools: ComputedRef<StructuredTool[]>;
     prompt: ChatLunaChatPrompt;
     agentMode: 'react' | 'tool-calling';
-    instructions?: ComputedRef<string>;
+    instructions?: ComputedRef<string | undefined>;
 }
 export interface AgentConfig {
     agent: Runnable;
     tools: StructuredTool[];
     agentMode: 'react' | 'tool-calling';
 }
-export interface CreateAgentExecutorOptions {
+export interface CreateAgentRunnerOptions {
     llm: ComputedRef<ChatLunaChatModel>;
     tools: ComputedRef<StructuredTool[]>;
     prompt: ChatLunaChatPrompt;
     agentMode: 'react' | 'tool-calling';
+    maxIterations?: number;
     returnIntermediateSteps?: boolean;
-    handleParsingErrors?: boolean;
-    instructions?: ComputedRef<string>;
+    handleParsingErrors?: boolean | string | ((e: Error) => string);
+    instructions?: ComputedRef<string | undefined>;
 }
+export type CreateAgentExecutorOptions = CreateAgentRunnerOptions;
 export declare function createAgentConfig(options: CreateAgentConfigOptions): ComputedRef<AgentConfig>;
-export declare function createAgentExecutor(options: CreateAgentExecutorOptions): ComputedRef<AgentExecutor>;
+export declare function createAgentRunner(options: CreateAgentRunnerOptions): ComputedRef<AgentRunner>;
+export declare const createAgentExecutor: typeof createAgentRunner;
 export interface CreateToolsRefOptions {
     tools: ComputedRef<ChatLunaTool[]>;
     embeddings: ChatLunaBaseEmbeddings;

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

@@ -1,49 +1,24 @@
-import { CallbackManagerForChainRun } from '@langchain/core/callbacks/manager';
-import { AIMessage } from '@langchain/core/messages';
-import { Runnable, type RunnableConfig } from '@langchain/core/runnables';
-import { StructuredTool, ToolInputParsingException } from '@langchain/core/tools';
+import { Runnable, RunnableConfig } from '@langchain/core/runnables';
+import type { StructuredTool } from '@langchain/core/tools';
 import type { ChainValues } from '@langchain/core/utils/types';
-import { BaseChain, ChainInputs } from 'koishi-plugin-chatluna/llm-core/chain/base';
-import { AgentEvent, AgentObservation, AgentStep, MessageQueue } from './types';
-export declare function runAgent(options: RunAgentOptions): AsyncGenerator<AgentEvent>;
-export declare class AgentExecutor extends BaseChain<ChainValues, AgentExecutorOutput> {
+import type { AgentExecutorInput, AgentExecutorOutput } from './legacy-executor';
+export { coerceToAgentObservation, LegacyAgentExecutor, runAgent, toToolInputErrorObservation, type AgentExecutorInput, type AgentExecutorOutput, type RunAgentOptions } from './legacy-executor';
+export declare class AgentRunner extends Runnable<ChainValues, AgentRunnerOutput> {
     lc_serializable: boolean;
+    lc_namespace: string[];
     agent: Runnable;
     tools: StructuredTool[];
     returnIntermediateSteps: boolean;
     maxIterations?: number;
     handleParsingErrors?: boolean | string | ((e: Error) => string);
     handleToolRuntimeErrors?: (e: Error) => string;
-    constructor(fields: AgentExecutorInput);
-    get inputKeys(): string[];
-    get outputKeys(): string[];
-    static fromAgentAndTools(fields: AgentExecutorInput): AgentExecutor;
-    _call(inputs: ChainValues, runManager?: CallbackManagerForChainRun, config?: RunnableConfig): Promise<AgentExecutorOutput>;
-    _chainType(): "agent_executor";
+    constructor(fields: AgentRunnerInput);
+    static fromAgentAndTools(fields: AgentRunnerInput): AgentRunner;
+    private _run;
+    invoke(input: ChainValues, options?: RunnableConfig): Promise<AgentRunnerOutput>;
+    _streamIterator(input: ChainValues, options?: RunnableConfig): AsyncGenerator<AgentRunnerOutput>;
 }
-export interface RunAgentOptions {
-    agent: Runnable;
-    tools: StructuredTool[];
-    input: ChainValues;
-    messageQueue?: MessageQueue;
-    signal?: AbortSignal;
-    maxIterations?: number;
-    handleParsingErrors?: boolean | string | ((e: Error) => string);
-    handleToolRuntimeErrors?: (e: Error) => string;
-    config?: RunnableConfig;
-}
-export interface AgentExecutorInput extends ChainInputs {
-    agent: Runnable;
-    tools: StructuredTool[];
-    returnIntermediateSteps?: boolean;
-    maxIterations?: number;
-    handleParsingErrors?: boolean | string | ((e: Error) => string);
-    handleToolRuntimeErrors?: (e: Error) => string;
-}
-export interface AgentExecutorOutput extends ChainValues {
-    output: string;
-    intermediateSteps?: AgentStep[];
-    message: AIMessage;
-}
-export declare function coerceToAgentObservation(observation: unknown, toolName?: string): AgentObservation;
-export declare function toToolInputErrorObservation(handleParsingErrors: boolean | string | ((e: Error) => string), error: ToolInputParsingException): AgentObservation;
+export declare const AgentExecutor: typeof AgentRunner;
+export type AgentExecutor = AgentRunner;
+export type AgentRunnerInput = AgentExecutorInput;
+export type AgentRunnerOutput = AgentExecutorOutput;