koishi-plugin-chatluna 1.0.0-beta.21 → 1.0.0-beta.22

package/lib/config.js

@@ -45,7 +45,7 @@ exports.Config = koishi_1.Schema.intersect([
             .description('分割消息发送（看起来更像普通水友（并且会不支持引用消息，不支持原始模式和图片模式。开启流式响应后启用该项会进行更细化的分割消息））')
             .default(false),
         censor: koishi_1.Schema.boolean()
-            .description('文本审核服务（需要安装 censor 服务')
+            .description('文本审核服务（需要安装 censor 服务）')
             .default(false),
         sendThinkingMessage: koishi_1.Schema.boolean()
             .description('发送等待消息，在请求时会发送这条消息')

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

@@ -0,0 +1,69 @@
+import { AgentAction, AgentFinish, AgentStep, BaseMessage, ChainValues, SystemMessage } from 'langchain/schema';
+import { OpenAIFunctionsAgentOutputParser, OpenAIToolsAgentOutputParser } from './output_parser';
+import { Agent, AgentArgs, AgentInput } from 'langchain/agents';
+import { CallbackManager } from 'langchain/callbacks';
+import { BaseLanguageModel } from 'langchain/base_language';
+import { BasePromptTemplate } from 'langchain/prompts';
+import { StructuredTool } from 'langchain/tools';
+export declare function _formatIntermediateSteps(intermediateSteps: AgentStep[]): BaseMessage[];
+/**
+ * Interface for the input data required to create an OpenAIAgent.
+ */
+export interface OpenAIAgentInput extends AgentInput {
+    tools: StructuredTool[];
+}
+/**
+ * Interface for the arguments required to create a prompt for an
+ * OpenAIAgent.
+ */
+export interface OpenAIAgentCreatePromptArgs {
+    prefix?: string;
+    systemMessage?: SystemMessage;
+}
+/**
+ * Class representing an agent for the OpenAI chat model in LangChain. It
+ * extends the Agent class and provides additional functionality specific
+ * to the OpenAIAgent type.
+ */
+export declare class OpenAIAgent extends Agent {
+    static lc_name(): string;
+    lc_namespace: string[];
+    _agentType(): "openai-functions";
+    observationPrefix(): string;
+    llmPrefix(): string;
+    _stop(): string[];
+    tools: StructuredTool[];
+    outputParser: OpenAIToolsAgentOutputParser | OpenAIFunctionsAgentOutputParser | any;
+    constructor(input: Omit<OpenAIAgentInput, 'outputParser'>);
+    /**
+     * Creates a prompt for the OpenAIAgent using the provided tools and
+     * fields.
+     * @param _tools The tools to be used in the prompt.
+     * @param fields Optional fields for creating the prompt.
+     * @returns A BasePromptTemplate object representing the created prompt.
+     */
+    static createPrompt(_tools: StructuredTool[], fields?: OpenAIAgentCreatePromptArgs): BasePromptTemplate;
+    /**
+     * Creates an OpenAIAgent from a BaseLanguageModel and a list of tools.
+     * @param llm The BaseLanguageModel to use.
+     * @param tools The tools to be used by the agent.
+     * @param args Optional arguments for creating the agent.
+     * @returns An instance of OpenAIAgent.
+     */
+    static fromLLMAndTools(llm: BaseLanguageModel, tools: StructuredTool[], args?: OpenAIAgentCreatePromptArgs & Pick<AgentArgs, 'callbacks'>): OpenAIAgent;
+    /**
+     * Constructs a scratch pad from a list of agent steps.
+     * @param steps The steps to include in the scratch pad.
+     * @returns A string or a list of BaseMessages representing the constructed scratch pad.
+     */
+    constructScratchPad(steps: AgentStep[]): Promise<string | BaseMessage[]>;
+    /**
+     * Plans the next action or finish state of the agent based on the
+     * provided steps, inputs, and optional callback manager.
+     * @param steps The steps to consider in planning.
+     * @param inputs The inputs to consider in planning.
+     * @param callbackManager Optional CallbackManager to use in planning.
+     * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.
+     */
+    plan(steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager): Promise<AgentAction | AgentFinish>;
+}

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

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIAgent = exports._formatIntermediateSteps = void 0;
+const schema_1 = require("langchain/schema");
+const output_parser_1 = require("./output_parser");
+const agents_1 = require("langchain/agents");
+const chains_1 = require("langchain/chains");
+const prompts_1 = require("langchain/prompts");
+const prompt_1 = require("./prompt");
+/**
+ * Checks if the given action is a FunctionsAgentAction.
+ * @param action The action to check.
+ * @returns True if the action is a FunctionsAgentAction, false otherwise.
+ */
+function isFunctionsAgentAction(action) {
+    return action.messageLog !== undefined;
+}
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function _convertAgentStepToMessages(action, observation) {
+    if (isFunctionsAgentAction(action) && action.messageLog !== undefined) {
+        return action.messageLog?.concat(new schema_1.FunctionMessage(observation, action.tool));
+    }
+    else {
+        return [new schema_1.AIMessage(action.log)];
+    }
+}
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function _formatIntermediateSteps(intermediateSteps) {
+    return intermediateSteps.flatMap(({ action, observation }) => _convertAgentStepToMessages(action, observation));
+}
+exports._formatIntermediateSteps = _formatIntermediateSteps;
+/**
+ * Class representing an agent for the OpenAI chat model in LangChain. It
+ * extends the Agent class and provides additional functionality specific
+ * to the OpenAIAgent type.
+ */
+class OpenAIAgent extends agents_1.Agent {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    static lc_name() {
+        return 'OpenAIAgent';
+    }
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    lc_namespace = ['langchain', 'agents', 'openai'];
+    _agentType() {
+        return 'openai-functions';
+    }
+    observationPrefix() {
+        return 'Observation: ';
+    }
+    llmPrefix() {
+        return 'Thought:';
+    }
+    _stop() {
+        return ['Observation:'];
+    }
+    tools;
+    outputParser = new output_parser_1.OpenAIFunctionsAgentOutputParser();
+    constructor(input) {
+        super({ ...input, outputParser: undefined });
+        this.tools = input.tools;
+    }
+    /**
+     * Creates a prompt for the OpenAIAgent using the provided tools and
+     * fields.
+     * @param _tools The tools to be used in the prompt.
+     * @param fields Optional fields for creating the prompt.
+     * @returns A BasePromptTemplate object representing the created prompt.
+     */
+    static createPrompt(_tools, fields) {
+        const { prefix = prompt_1.PREFIX } = fields || {};
+        return prompts_1.ChatPromptTemplate.fromMessages([
+            prompts_1.SystemMessagePromptTemplate.fromTemplate(prefix),
+            new prompts_1.MessagesPlaceholder('chat_history'),
+            prompts_1.HumanMessagePromptTemplate.fromTemplate('{input}'),
+            new prompts_1.MessagesPlaceholder('agent_scratchpad')
+        ]);
+    }
+    /**
+     * Creates an OpenAIAgent from a BaseLanguageModel and a list of tools.
+     * @param llm The BaseLanguageModel to use.
+     * @param tools The tools to be used by the agent.
+     * @param args Optional arguments for creating the agent.
+     * @returns An instance of OpenAIAgent.
+     */
+    static fromLLMAndTools(llm, tools, args) {
+        OpenAIAgent.validateTools(tools);
+        /*  if (
+            llm._modelType() !== 'base_chat_model' ||
+            llm._llmType() !== 'openai'
+        ) {
+            throw new Error('OpenAIAgent requires an OpenAI chat model')
+        } */
+        const prompt = OpenAIAgent.createPrompt(tools, args);
+        const chain = new chains_1.LLMChain({
+            prompt,
+            llm,
+            callbacks: args?.callbacks
+        });
+        return new OpenAIAgent({
+            llmChain: chain,
+            allowedTools: tools.map((t) => t.name),
+            tools
+        });
+    }
+    /**
+     * Constructs a scratch pad from a list of agent steps.
+     * @param steps The steps to include in the scratch pad.
+     * @returns A string or a list of BaseMessages representing the constructed scratch pad.
+     */
+    async constructScratchPad(steps) {
+        return _formatIntermediateSteps(steps);
+    }
+    /**
+     * Plans the next action or finish state of the agent based on the
+     * provided steps, inputs, and optional callback manager.
+     * @param steps The steps to consider in planning.
+     * @param inputs The inputs to consider in planning.
+     * @param callbackManager Optional CallbackManager to use in planning.
+     * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.
+     */
+    async plan(steps, inputs, callbackManager) {
+        // Add scratchpad and stop to inputs
+        const thoughts = await this.constructScratchPad(steps);
+        const newInputs = {
+            ...inputs,
+            agent_scratchpad: thoughts
+        };
+        if (this._stop().length !== 0) {
+            newInputs.stop = this._stop();
+        }
+        // Split inputs between prompt and llm
+        const llm = this.llmChain.llm;
+        const valuesForPrompt = { ...newInputs };
+        const valuesForLLM = {
+            tools: this.tools
+        };
+        const callKeys = 'callKeys' in this.llmChain.llm ? this.llmChain.llm.callKeys : [];
+        for (const key of callKeys) {
+            if (key in inputs) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                valuesForLLM[key] =
+                    inputs[key];
+                delete valuesForPrompt[key];
+            }
+        }
+        const promptValue = await this.llmChain.prompt.formatPromptValue(valuesForPrompt);
+        const message = await llm.predictMessages(promptValue.toChatMessages(), valuesForLLM, callbackManager);
+        if (message.additional_kwargs.tool_calls &&
+            this.outputParser instanceof output_parser_1.OpenAIFunctionsAgentOutputParser) {
+            this.outputParser = new output_parser_1.OpenAIToolsAgentOutputParser();
+        }
+        else if (message.additional_kwargs.function_call &&
+            this.outputParser instanceof output_parser_1.OpenAIToolsAgentOutputParser) {
+            this.outputParser = new output_parser_1.OpenAIFunctionsAgentOutputParser();
+        }
+        return this.outputParser.parseAIMessage(message);
+    }
+}
+exports.OpenAIAgent = OpenAIAgent;

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

@@ -0,0 +1,69 @@
+import { AgentAction, AgentFinish, AgentStep, BaseMessage, ChainValues, SystemMessage } from 'langchain/schema';
+import { OpenAIFunctionsAgentOutputParser, OpenAIToolsAgentOutputParser } from './output_parser';
+import { Agent, AgentArgs, AgentInput } from 'langchain/agents';
+import { CallbackManager } from 'langchain/callbacks';
+import { BaseLanguageModel } from 'langchain/base_language';
+import { BasePromptTemplate } from 'langchain/prompts';
+import { StructuredTool } from 'langchain/tools';
+export declare function _formatIntermediateSteps(intermediateSteps: AgentStep[]): BaseMessage[];
+/**
+ * Interface for the input data required to create an OpenAIAgent.
+ */
+export interface OpenAIAgentInput extends AgentInput {
+    tools: StructuredTool[];
+}
+/**
+ * Interface for the arguments required to create a prompt for an
+ * OpenAIAgent.
+ */
+export interface OpenAIAgentCreatePromptArgs {
+    prefix?: string;
+    systemMessage?: SystemMessage;
+}
+/**
+ * Class representing an agent for the OpenAI chat model in LangChain. It
+ * extends the Agent class and provides additional functionality specific
+ * to the OpenAIAgent type.
+ */
+export declare class OpenAIAgent extends Agent {
+    static lc_name(): string;
+    lc_namespace: string[];
+    _agentType(): "openai-functions";
+    observationPrefix(): string;
+    llmPrefix(): string;
+    _stop(): string[];
+    tools: StructuredTool[];
+    outputParser: OpenAIToolsAgentOutputParser | OpenAIFunctionsAgentOutputParser | any;
+    constructor(input: Omit<OpenAIAgentInput, 'outputParser'>);
+    /**
+     * Creates a prompt for the OpenAIAgent using the provided tools and
+     * fields.
+     * @param _tools The tools to be used in the prompt.
+     * @param fields Optional fields for creating the prompt.
+     * @returns A BasePromptTemplate object representing the created prompt.
+     */
+    static createPrompt(_tools: StructuredTool[], fields?: OpenAIAgentCreatePromptArgs): BasePromptTemplate;
+    /**
+     * Creates an OpenAIAgent from a BaseLanguageModel and a list of tools.
+     * @param llm The BaseLanguageModel to use.
+     * @param tools The tools to be used by the agent.
+     * @param args Optional arguments for creating the agent.
+     * @returns An instance of OpenAIAgent.
+     */
+    static fromLLMAndTools(llm: BaseLanguageModel, tools: StructuredTool[], args?: OpenAIAgentCreatePromptArgs & Pick<AgentArgs, 'callbacks'>): OpenAIAgent;
+    /**
+     * Constructs a scratch pad from a list of agent steps.
+     * @param steps The steps to include in the scratch pad.
+     * @returns A string or a list of BaseMessages representing the constructed scratch pad.
+     */
+    constructScratchPad(steps: AgentStep[]): Promise<string | BaseMessage[]>;
+    /**
+     * Plans the next action or finish state of the agent based on the
+     * provided steps, inputs, and optional callback manager.
+     * @param steps The steps to consider in planning.
+     * @param inputs The inputs to consider in planning.
+     * @param callbackManager Optional CallbackManager to use in planning.
+     * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.
+     */
+    plan(steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager): Promise<AgentAction | AgentFinish>;
+}

package/lib/llm-core/agent/openai/index.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIAgent = exports._formatIntermediateSteps = void 0;
+const schema_1 = require("langchain/schema");
+const output_parser_1 = require("./output_parser");
+const agents_1 = require("langchain/agents");
+const chains_1 = require("langchain/chains");
+const prompts_1 = require("langchain/prompts");
+const prompt_1 = require("./prompt");
+/**
+ * Checks if the given action is a FunctionsAgentAction.
+ * @param action The action to check.
+ * @returns True if the action is a FunctionsAgentAction, false otherwise.
+ */
+function isFunctionsAgentAction(action) {
+    return action.messageLog !== undefined;
+}
+function isToolsAgentAction(action) {
+    return action.toolCallId !== undefined;
+}
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function _convertAgentStepToMessages(action, observation) {
+    if (isToolsAgentAction(action) && action.toolCallId !== undefined) {
+        const log = action.messageLog;
+        return log.concat(new schema_1.ToolMessage({
+            content: observation,
+            name: action.tool,
+            tool_call_id: action.toolCallId
+        }));
+    }
+    else if (isFunctionsAgentAction(action) &&
+        action.messageLog !== undefined) {
+        return action.messageLog?.concat(new schema_1.FunctionMessage(observation, action.tool));
+    }
+    else {
+        return [new schema_1.AIMessage(action.log)];
+    }
+}
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function _formatIntermediateSteps(intermediateSteps) {
+    return intermediateSteps.flatMap(({ action, observation }) => _convertAgentStepToMessages(action, observation));
+}
+exports._formatIntermediateSteps = _formatIntermediateSteps;
+/**
+ * Class representing an agent for the OpenAI chat model in LangChain. It
+ * extends the Agent class and provides additional functionality specific
+ * to the OpenAIAgent type.
+ */
+class OpenAIAgent extends agents_1.Agent {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    static lc_name() {
+        return 'OpenAIAgent';
+    }
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    lc_namespace = ['langchain', 'agents', 'openai'];
+    _agentType() {
+        return 'openai-functions';
+    }
+    observationPrefix() {
+        return 'Observation: ';
+    }
+    llmPrefix() {
+        return 'Thought:';
+    }
+    _stop() {
+        return ['Observation:'];
+    }
+    tools;
+    outputParser = new output_parser_1.OpenAIFunctionsAgentOutputParser();
+    constructor(input) {
+        super({ ...input, outputParser: undefined });
+        this.tools = input.tools;
+    }
+    /**
+     * Creates a prompt for the OpenAIAgent using the provided tools and
+     * fields.
+     * @param _tools The tools to be used in the prompt.
+     * @param fields Optional fields for creating the prompt.
+     * @returns A BasePromptTemplate object representing the created prompt.
+     */
+    static createPrompt(_tools, fields) {
+        const { prefix = prompt_1.PREFIX } = fields || {};
+        return prompts_1.ChatPromptTemplate.fromMessages([
+            prompts_1.SystemMessagePromptTemplate.fromTemplate(prefix),
+            new prompts_1.MessagesPlaceholder('chat_history'),
+            prompts_1.HumanMessagePromptTemplate.fromTemplate('{input}'),
+            new prompts_1.MessagesPlaceholder('agent_scratchpad')
+        ]);
+    }
+    /**
+     * Creates an OpenAIAgent from a BaseLanguageModel and a list of tools.
+     * @param llm The BaseLanguageModel to use.
+     * @param tools The tools to be used by the agent.
+     * @param args Optional arguments for creating the agent.
+     * @returns An instance of OpenAIAgent.
+     */
+    static fromLLMAndTools(llm, tools, args) {
+        OpenAIAgent.validateTools(tools);
+        /*  if (
+            llm._modelType() !== 'base_chat_model' ||
+            llm._llmType() !== 'openai'
+        ) {
+            throw new Error('OpenAIAgent requires an OpenAI chat model')
+        } */
+        const prompt = OpenAIAgent.createPrompt(tools, args);
+        const chain = new chains_1.LLMChain({
+            prompt,
+            llm,
+            callbacks: args?.callbacks
+        });
+        return new OpenAIAgent({
+            llmChain: chain,
+            allowedTools: tools.map((t) => t.name),
+            tools
+        });
+    }
+    /**
+     * Constructs a scratch pad from a list of agent steps.
+     * @param steps The steps to include in the scratch pad.
+     * @returns A string or a list of BaseMessages representing the constructed scratch pad.
+     */
+    async constructScratchPad(steps) {
+        return _formatIntermediateSteps(steps);
+    }
+    /**
+     * Plans the next action or finish state of the agent based on the
+     * provided steps, inputs, and optional callback manager.
+     * @param steps The steps to consider in planning.
+     * @param inputs The inputs to consider in planning.
+     * @param callbackManager Optional CallbackManager to use in planning.
+     * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.
+     */
+    async plan(steps, inputs, callbackManager) {
+        // Add scratchpad and stop to inputs
+        const thoughts = await this.constructScratchPad(steps);
+        const newInputs = {
+            ...inputs,
+            agent_scratchpad: thoughts
+        };
+        if (this._stop().length !== 0) {
+            newInputs.stop = this._stop();
+        }
+        // Split inputs between prompt and llm
+        const llm = this.llmChain.llm;
+        const valuesForPrompt = { ...newInputs };
+        const valuesForLLM = {
+            tools: this.tools
+        };
+        const callKeys = 'callKeys' in this.llmChain.llm ? this.llmChain.llm.callKeys : [];
+        for (const key of callKeys) {
+            if (key in inputs) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                valuesForLLM[key] =
+                    inputs[key];
+                delete valuesForPrompt[key];
+            }
+        }
+        const promptValue = await this.llmChain.prompt.formatPromptValue(valuesForPrompt);
+        const message = await llm.predictMessages(promptValue.toChatMessages(), valuesForLLM, callbackManager);
+        if (message.additional_kwargs.tool_calls &&
+            this.outputParser instanceof output_parser_1.OpenAIFunctionsAgentOutputParser) {
+            this.outputParser = new output_parser_1.OpenAIToolsAgentOutputParser();
+        }
+        else if (message.additional_kwargs.function_call &&
+            this.outputParser instanceof output_parser_1.OpenAIToolsAgentOutputParser) {
+            this.outputParser = new output_parser_1.OpenAIFunctionsAgentOutputParser();
+        }
+        return this.outputParser.parseAIMessage(message);
+    }
+}
+exports.OpenAIAgent = OpenAIAgent;

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

@@ -0,0 +1,59 @@
+import { AgentAction, AgentFinish, AgentStep, BaseMessage, ChatGeneration } from 'langchain/schema';
+import { BaseOutputParser } from 'langchain/schema/output_parser';
+/**
+ * Type that represents an agent action with an optional message log.
+ */
+export type FunctionsAgentAction = AgentAction & {
+    messageLog?: BaseMessage[];
+};
+/**
+ * Abstract class representing an output parser specifically for agent
+ * actions and finishes in LangChain. It extends the `BaseOutputParser`
+ * class.
+ */
+export declare abstract class AgentActionOutputParser extends BaseOutputParser<AgentAction | AgentFinish> {
+}
+/**
+ * Abstract class representing an output parser specifically for agents
+ * that return multiple actions.
+ */
+export declare abstract class AgentMultiActionOutputParser extends BaseOutputParser<AgentAction[] | AgentFinish> {
+}
+export declare class OpenAIFunctionsAgentOutputParser extends AgentActionOutputParser {
+    lc_namespace: string[];
+    static lc_name(): string;
+    parse(text: string): Promise<AgentAction | AgentFinish>;
+    parseResult(generations: ChatGeneration[]): Promise<FunctionsAgentAction | AgentFinish>;
+    /**
+     * Parses the output message into a FunctionsAgentAction or AgentFinish
+     * object.
+     * @param message The BaseMessage to parse.
+     * @returns A FunctionsAgentAction or AgentFinish object.
+     */
+    parseAIMessage(message: BaseMessage): FunctionsAgentAction | AgentFinish;
+    getFormatInstructions(): string;
+}
+/**
+ * Type that represents an agent action with an optional message log.
+ */
+export type ToolsAgentAction = AgentAction & {
+    toolCallId: string;
+    messageLog?: BaseMessage[];
+};
+export type ToolsAgentStep = AgentStep & {
+    action: ToolsAgentAction;
+};
+export declare class OpenAIToolsAgentOutputParser extends AgentMultiActionOutputParser {
+    lc_namespace: string[];
+    static lc_name(): string;
+    parse(text: string): Promise<AgentAction[] | AgentFinish>;
+    parseResult(generations: ChatGeneration[]): Promise<AgentFinish | ToolsAgentAction[]>;
+    /**
+     * Parses the output message into a ToolsAgentAction[] or AgentFinish
+     * object.
+     * @param message The BaseMessage to parse.
+     * @returns A ToolsAgentAction[] or AgentFinish object.
+     */
+    parseAIMessage(message: BaseMessage): ToolsAgentAction[] | AgentFinish;
+    getFormatInstructions(): string;
+}

package/lib/llm-core/agent/openai/output_parser.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIToolsAgentOutputParser = exports.OpenAIFunctionsAgentOutputParser = exports.AgentMultiActionOutputParser = exports.AgentActionOutputParser = void 0;
+const schema_1 = require("langchain/schema");
+const output_parser_1 = require("langchain/schema/output_parser");
+// F** langchain
+/**
+ * Abstract class representing an output parser specifically for agent
+ * actions and finishes in LangChain. It extends the `BaseOutputParser`
+ * class.
+ */
+class AgentActionOutputParser extends output_parser_1.BaseOutputParser {
+}
+exports.AgentActionOutputParser = AgentActionOutputParser;
+/**
+ * Abstract class representing an output parser specifically for agents
+ * that return multiple actions.
+ */
+class AgentMultiActionOutputParser extends output_parser_1.BaseOutputParser {
+}
+exports.AgentMultiActionOutputParser = AgentMultiActionOutputParser;
+class OpenAIFunctionsAgentOutputParser extends AgentActionOutputParser {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    lc_namespace = ['langchain', 'agents', 'openai'];
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    static lc_name() {
+        return 'OpenAIFunctionsAgentOutputParser';
+    }
+    async parse(text) {
+        throw new Error(`OpenAIFunctionsAgentOutputParser can only parse messages.\nPassed input: ${text}`);
+    }
+    async parseResult(generations) {
+        if ('message' in generations[0] &&
+            (0, schema_1.isBaseMessage)(generations[0].message)) {
+            return this.parseAIMessage(generations[0].message);
+        }
+        throw new Error('parseResult on OpenAIFunctionsAgentOutputParser only works on ChatGeneration output');
+    }
+    /**
+     * Parses the output message into a FunctionsAgentAction or AgentFinish
+     * object.
+     * @param message The BaseMessage to parse.
+     * @returns A FunctionsAgentAction or AgentFinish object.
+     */
+    parseAIMessage(message) {
+        if (message.content && typeof message.content !== 'string') {
+            throw new Error('This agent cannot parse non-string model responses.');
+        }
+        if (message.additional_kwargs.function_call) {
+            // eslint-disable-next-line prefer-destructuring, @typescript-eslint/naming-convention
+            const function_call = message.additional_kwargs.function_call;
+            try {
+                const toolInput = function_call.arguments
+                    ? JSON.parse(function_call.arguments)
+                    : {};
+                return {
+                    tool: function_call.name,
+                    toolInput,
+                    log: `Invoking "${function_call.name}" with ${function_call.arguments ?? '{}'}\n${message.content}`,
+                    messageLog: [message]
+                };
+            }
+            catch (error) {
+                throw new output_parser_1.OutputParserException(`Failed to parse function arguments from chat model response. Text: "${function_call.arguments}". ${error}`);
+            }
+        }
+        else {
+            return {
+                returnValues: { output: message.content },
+                log: message.content
+            };
+        }
+    }
+    getFormatInstructions() {
+        throw new Error('getFormatInstructions not implemented inside OpenAIFunctionsAgentOutputParser.');
+    }
+}
+exports.OpenAIFunctionsAgentOutputParser = OpenAIFunctionsAgentOutputParser;
+class OpenAIToolsAgentOutputParser extends AgentMultiActionOutputParser {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    lc_namespace = ['langchain', 'agents', 'openai'];
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    static lc_name() {
+        return 'OpenAIToolsAgentOutputParser';
+    }
+    async parse(text) {
+        throw new Error(`OpenAIFunctionsAgentOutputParser can only parse messages.\nPassed input: ${text}`);
+    }
+    async parseResult(generations) {
+        if ('message' in generations[0] &&
+            (0, schema_1.isBaseMessage)(generations[0].message)) {
+            return this.parseAIMessage(generations[0].message);
+        }
+        throw new Error('parseResult on OpenAIFunctionsAgentOutputParser only works on ChatGeneration output');
+    }
+    /**
+     * Parses the output message into a ToolsAgentAction[] or AgentFinish
+     * object.
+     * @param message The BaseMessage to parse.
+     * @returns A ToolsAgentAction[] or AgentFinish object.
+     */
+    parseAIMessage(message) {
+        if (message.content && typeof message.content !== 'string') {
+            throw new Error('This agent cannot parse non-string model responses.');
+        }
+        if (message.additional_kwargs.tool_calls) {
+            const toolCalls = message
+                .additional_kwargs.tool_calls;
+            try {
+                return toolCalls.map((toolCall, i) => {
+                    const toolInput = toolCall.function.arguments
+                        ? JSON.parse(toolCall.function.arguments)
+                        : {};
+                    const messageLog = i === 0 ? [message] : [];
+                    return {
+                        tool: toolCall.function.name,
+                        toolInput,
+                        toolCallId: toolCall.id,
+                        log: `Invoking "${toolCall.function.name}" with ${toolCall.function.arguments ?? '{}'}\n${message.content}`,
+                        messageLog
+                    };
+                });
+            }
+            catch (error) {
+                throw new output_parser_1.OutputParserException(`Failed to parse tool arguments from chat model response. Text: "${JSON.stringify(toolCalls)}". ${error}`);
+            }
+        }
+        else {
+            return {
+                returnValues: { output: message.content },
+                log: message.content
+            };
+        }
+    }
+    getFormatInstructions() {
+        throw new Error('getFormatInstructions not implemented inside OpenAIToolsAgentOutputParser.');
+    }
+}
+exports.OpenAIToolsAgentOutputParser = OpenAIToolsAgentOutputParser;

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

@@ -0,0 +1,2 @@
+export declare const PREFIX = "You are a helpful AI assistant.";
+export declare const SUFFIX = "";