@langchain/classic 1.0.0-alpha.1

package/dist/agents/structured_chat/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["input: StructuredChatAgentInput","tools: StructuredToolInterface[]","fields?: OutputParserArgs & {\n      toolNames: string[];\n    }","steps: AgentStep[]","args?: StructuredChatCreatePromptArgs","llm: BaseLanguageModelInterface","args?: StructuredChatCreatePromptArgs & AgentArgs","toolNames: string[]","input: { steps: AgentStep[] }"],"sources":["../../../src/agents/structured_chat/index.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport {\n  isOpenAITool,\n  type BaseLanguageModel,\n  type BaseLanguageModelInterface,\n  type ToolDefinition,\n} from \"@langchain/core/language_models/base\";\nimport { RunnablePassthrough } from \"@langchain/core/runnables\";\nimport type { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport {\n  BaseMessagePromptTemplate,\n  ChatPromptTemplate,\n  HumanMessagePromptTemplate,\n  SystemMessagePromptTemplate,\n  PromptTemplate,\n} from \"@langchain/core/prompts\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { isStructuredTool } from \"@langchain/core/utils/function_calling\";\nimport { isInteropZodSchema } from \"@langchain/core/utils/types\";\nimport {\n  type JsonSchema7Type,\n  toJsonSchema,\n} from \"@langchain/core/utils/json_schema\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport {\n  Agent,\n  AgentArgs,\n  AgentRunnableSequence,\n  OutputParserArgs,\n} from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { StructuredChatOutputParserWithRetries } from \"./outputParser.js\";\nimport { FORMAT_INSTRUCTIONS, PREFIX, SUFFIX } from \"./prompt.js\";\nimport { renderTextDescriptionAndArgs } from \"../../tools/render.js\";\nimport { formatLogToString } from \"../format_scratchpad/log.js\";\n\n/**\n * Interface for arguments used to create a prompt for a\n * StructuredChatAgent.\n */\nexport interface StructuredChatCreatePromptArgs {\n  /** String to put after the list of tools. */\n  suffix?: string;\n  /** String to put before the list of tools. */\n  prefix?: string;\n  /** String to use directly as the human message template. */\n  humanMessageTemplate?: string;\n  /** List of input variables the final prompt will expect. */\n  inputVariables?: string[];\n  /** List of historical prompts from memory.  */\n  memoryPrompts?: BaseMessagePromptTemplate[];\n}\n\n/**\n * Type for input data for creating a StructuredChatAgent, with the\n * 'outputParser' property made optional.\n */\nexport type StructuredChatAgentInput = Optional<AgentInput, \"outputParser\">;\n\n/**\n * Agent that interoperates with Structured Tools using React logic.\n * @augments Agent\n */\nexport class StructuredChatAgent extends Agent {\n  static lc_name() {\n    return \"StructuredChatAgent\";\n  }\n\n  lc_namespace = [\"langchain\", \"agents\", \"structured_chat\"];\n\n  constructor(input: StructuredChatAgentInput) {\n    const outputParser =\n      input?.outputParser ?? StructuredChatAgent.getDefaultOutputParser();\n    super({ ...input, outputParser });\n  }\n\n  _agentType() {\n    return \"structured-chat-zero-shot-react-description\" as const;\n  }\n\n  observationPrefix() {\n    return \"Observation: \";\n  }\n\n  llmPrefix() {\n    return \"Thought:\";\n  }\n\n  _stop(): string[] {\n    return [\"Observation:\"];\n  }\n\n  /**\n   * Validates that all provided tools have a description. Throws an error\n   * if any tool lacks a description.\n   * @param tools Array of StructuredTool instances to validate.\n   */\n  static validateTools(tools: StructuredToolInterface[]) {\n    const descriptionlessTool = tools.find((tool) => !tool.description);\n    if (descriptionlessTool) {\n      const msg =\n        `Got a tool ${descriptionlessTool.name} without a description.` +\n        ` This agent requires descriptions for all tools.`;\n      throw new Error(msg);\n    }\n  }\n\n  /**\n   * Returns a default output parser for the StructuredChatAgent. If an LLM\n   * is provided, it creates an output parser with retry logic from the LLM.\n   * @param fields Optional fields to customize the output parser. Can include an LLM and a list of tool names.\n   * @returns An instance of StructuredChatOutputParserWithRetries.\n   */\n  static getDefaultOutputParser(\n    fields?: OutputParserArgs & {\n      toolNames: string[];\n    }\n  ) {\n    if (fields?.llm) {\n      return StructuredChatOutputParserWithRetries.fromLLM(fields.llm, {\n        toolNames: fields.toolNames,\n      });\n    }\n    return new StructuredChatOutputParserWithRetries({\n      toolNames: fields?.toolNames,\n    });\n  }\n\n  /**\n   * Constructs the agent's scratchpad from a list of steps. If the agent's\n   * scratchpad is not empty, it prepends a message indicating that the\n   * agent has not seen any previous work.\n   * @param steps Array of AgentStep instances to construct the scratchpad from.\n   * @returns A Promise that resolves to a string representing the agent's scratchpad.\n   */\n  async constructScratchPad(steps: AgentStep[]): Promise<string> {\n    const agentScratchpad = await super.constructScratchPad(steps);\n    if (agentScratchpad) {\n      return `This was your previous work (but I haven't seen any of it! I only see what you return as final answer):\\n${agentScratchpad}`;\n    }\n    return agentScratchpad;\n  }\n\n  /**\n   * Creates a string representation of the schemas of the provided tools.\n   * @param tools Array of StructuredTool instances to create the schemas string from.\n   * @returns A string representing the schemas of the provided tools.\n   */\n  static createToolSchemasString(tools: StructuredToolInterface[]) {\n    return tools\n      .map((tool) => {\n        const jsonSchema = (\n          isInteropZodSchema(tool.schema)\n            ? toJsonSchema(tool.schema)\n            : tool.schema\n        ) as { properties?: Record<string, JsonSchema7Type> } | undefined;\n        return `${tool.name}: ${tool.description}, args: ${JSON.stringify(\n          jsonSchema?.properties\n        )}`;\n      })\n      .join(\"\\n\");\n  }\n\n  /**\n   * Create prompt in the style of the agent.\n   *\n   * @param tools - List of tools the agent will have access to, used to format the prompt.\n   * @param args - Arguments to create the prompt with.\n   * @param args.suffix - String to put after the list of tools.\n   * @param args.prefix - String to put before the list of tools.\n   * @param args.inputVariables List of input variables the final prompt will expect.\n   * @param args.memoryPrompts List of historical prompts from memory.\n   */\n  static createPrompt(\n    tools: StructuredToolInterface[],\n    args?: StructuredChatCreatePromptArgs\n  ) {\n    const {\n      prefix = PREFIX,\n      suffix = SUFFIX,\n      inputVariables = [\"input\", \"agent_scratchpad\"],\n      humanMessageTemplate = \"{input}\\n\\n{agent_scratchpad}\",\n      memoryPrompts = [],\n    } = args ?? {};\n    const template = [prefix, FORMAT_INSTRUCTIONS, suffix].join(\"\\n\\n\");\n    const messages = [\n      new SystemMessagePromptTemplate(\n        new PromptTemplate({\n          template,\n          inputVariables,\n          partialVariables: {\n            tool_schemas: StructuredChatAgent.createToolSchemasString(tools),\n            tool_names: tools.map((tool) => tool.name).join(\", \"),\n          },\n        })\n      ),\n      ...memoryPrompts,\n      new HumanMessagePromptTemplate(\n        new PromptTemplate({\n          template: humanMessageTemplate,\n          inputVariables,\n        })\n      ),\n    ];\n    return ChatPromptTemplate.fromMessages(messages);\n  }\n\n  /**\n   * Creates a StructuredChatAgent from an LLM and a list of tools.\n   * Validates the tools, creates a prompt, and sets up an LLM chain for the\n   * agent.\n   * @param llm BaseLanguageModel instance to create the agent from.\n   * @param tools Array of StructuredTool instances to create the agent from.\n   * @param args Optional arguments to customize the creation of the agent. Can include arguments for creating the prompt and AgentArgs.\n   * @returns A new instance of StructuredChatAgent.\n   */\n  static fromLLMAndTools(\n    llm: BaseLanguageModelInterface,\n    tools: StructuredToolInterface[],\n    args?: StructuredChatCreatePromptArgs & AgentArgs\n  ) {\n    StructuredChatAgent.validateTools(tools);\n    const prompt = StructuredChatAgent.createPrompt(tools, args);\n    const outputParser =\n      args?.outputParser ??\n      StructuredChatAgent.getDefaultOutputParser({\n        llm,\n        toolNames: tools.map((tool) => tool.name),\n      });\n    const chain = new LLMChain({\n      prompt,\n      llm,\n      callbacks: args?.callbacks,\n    });\n\n    return new StructuredChatAgent({\n      llmChain: chain,\n      outputParser,\n      allowedTools: tools.map((t) => t.name),\n    });\n  }\n}\n\n/**\n * Params used by the createStructuredChatAgent function.\n */\nexport type CreateStructuredChatAgentParams = {\n  /** LLM to use as the agent. */\n  llm: BaseLanguageModelInterface;\n  /** Tools this agent has access to. */\n  tools: (StructuredToolInterface | ToolDefinition)[];\n  /**\n   * The prompt to use. Must have input keys for\n   * `tools`, `tool_names`, and `agent_scratchpad`.\n   */\n  prompt: BasePromptTemplate;\n  /**\n   * Whether to invoke the underlying model in streaming mode,\n   * allowing streaming of intermediate steps. Defaults to true.\n   */\n  streamRunnable?: boolean;\n};\n\n/**\n * Create an agent aimed at supporting tools with multiple inputs.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createStructuredChatAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/structured-chat-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/structured-chat-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createStructuredChatAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport async function createStructuredChatAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateStructuredChatAgentParams) {\n  const missingVariables = [\"tools\", \"tool_names\", \"agent_scratchpad\"].filter(\n    (v) => !prompt.inputVariables.includes(v)\n  );\n  if (missingVariables.length > 0) {\n    throw new Error(\n      `Provided prompt is missing required input variables: ${JSON.stringify(\n        missingVariables\n      )}`\n    );\n  }\n  let toolNames: string[] = [];\n  if (tools.every(isOpenAITool)) {\n    toolNames = tools.map((tool) => tool.function.name);\n  } else if (tools.every(isStructuredTool)) {\n    toolNames = tools.map((tool) => tool.name);\n  } else {\n    throw new Error(\n      \"All tools must be either OpenAI or Structured tools, not a mix.\"\n    );\n  }\n  const partialedPrompt = await prompt.partial({\n    tools: renderTextDescriptionAndArgs(tools),\n    tool_names: toolNames.join(\", \"),\n  });\n  // TODO: Add .bind to core runnable interface.\n  const llmWithStop = (llm as BaseLanguageModel).withConfig({\n    stop: [\"Observation\"],\n  });\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: AgentStep[] }) =>\n          formatLogToString(input.steps),\n      }),\n      partialedPrompt,\n      llmWithStop,\n      StructuredChatOutputParserWithRetries.fromLLM(llm, {\n        toolNames,\n      }),\n    ],\n    {\n      name: \"StructuredChatAgent\",\n      streamRunnable,\n      singleAction: true,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAgEA,IAAa,sBAAb,MAAa,4BAA4B,MAAM;CAC7C,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe;EAAC;EAAa;EAAU;CAAkB;CAEzD,YAAYA,OAAiC;EAC3C,MAAM,eACJ,OAAO,gBAAgB,oBAAoB,wBAAwB;EACrE,MAAM;GAAE,GAAG;GAAO;EAAc,EAAC;CAClC;CAED,aAAa;AACX,SAAO;CACR;CAED,oBAAoB;AAClB,SAAO;CACR;CAED,YAAY;AACV,SAAO;CACR;CAED,QAAkB;AAChB,SAAO,CAAC,cAAe;CACxB;;;;;;CAOD,OAAO,cAAcC,OAAkC;EACrD,MAAM,sBAAsB,MAAM,KAAK,CAAC,SAAS,CAAC,KAAK,YAAY;AACnE,MAAI,qBAAqB;GACvB,MAAM,MACJ,CAAC,WAAW,EAAE,oBAAoB,KAAK,uEAAuB,CACZ;AACpD,SAAM,IAAI,MAAM;EACjB;CACF;;;;;;;CAQD,OAAO,uBACLC,QAGA;AACA,MAAI,QAAQ,IACV,QAAO,sCAAsC,QAAQ,OAAO,KAAK,EAC/D,WAAW,OAAO,UACnB,EAAC;AAEJ,SAAO,IAAI,sCAAsC,EAC/C,WAAW,QAAQ,UACpB;CACF;;;;;;;;CASD,MAAM,oBAAoBC,OAAqC;EAC7D,MAAM,kBAAkB,MAAM,MAAM,oBAAoB,MAAM;AAC9D,MAAI,gBACF,QAAO,CAAC,yGAAyG,EAAE,iBAAiB;AAEtI,SAAO;CACR;;;;;;CAOD,OAAO,wBAAwBF,OAAkC;AAC/D,SAAO,MACJ,IAAI,CAAC,SAAS;GACb,MAAM,aACJ,mBAAmB,KAAK,OAAO,GAC3B,aAAa,KAAK,OAAO,GACzB,KAAK;AAEX,UAAO,GAAG,KAAK,KAAK,EAAE,EAAE,KAAK,YAAY,QAAQ,EAAE,KAAK,UACtD,YAAY,WACb,EAAE;EACJ,EAAC,CACD,KAAK,KAAK;CACd;;;;;;;;;;;CAYD,OAAO,aACLA,OACAG,MACA;EACA,MAAM,EACJ,SAAS,QACT,SAAS,QACT,iBAAiB,CAAC,SAAS,kBAAmB,GAC9C,uBAAuB,iCACvB,gBAAgB,CAAE,GACnB,GAAG,QAAQ,CAAE;EACd,MAAM,WAAW;GAAC;GAAQ;GAAqB;EAAO,EAAC,KAAK,OAAO;EACnE,MAAM,WAAW;GACf,IAAI,4BACF,IAAI,eAAe;IACjB;IACA;IACA,kBAAkB;KAChB,cAAc,oBAAoB,wBAAwB,MAAM;KAChE,YAAY,MAAM,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,KAAK,KAAK;IACtD;GACF;GAEH,GAAG;GACH,IAAI,2BACF,IAAI,eAAe;IACjB,UAAU;IACV;GACD;EAEJ;AACD,SAAO,mBAAmB,aAAa,SAAS;CACjD;;;;;;;;;;CAWD,OAAO,gBACLC,KACAJ,OACAK,MACA;EACA,oBAAoB,cAAc,MAAM;EACxC,MAAM,SAAS,oBAAoB,aAAa,OAAO,KAAK;EAC5D,MAAM,eACJ,MAAM,gBACN,oBAAoB,uBAAuB;GACzC;GACA,WAAW,MAAM,IAAI,CAAC,SAAS,KAAK,KAAK;EAC1C,EAAC;EACJ,MAAM,QAAQ,IAAI,SAAS;GACzB;GACA;GACA,WAAW,MAAM;EAClB;AAED,SAAO,IAAI,oBAAoB;GAC7B,UAAU;GACV;GACA,cAAc,MAAM,IAAI,CAAC,MAAM,EAAE,KAAK;EACvC;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8ED,eAAsB,0BAA0B,EAC9C,KACA,OACA,QACA,gBACgC,EAAE;CAClC,MAAM,mBAAmB;EAAC;EAAS;EAAc;CAAmB,EAAC,OACnE,CAAC,MAAM,CAAC,OAAO,eAAe,SAAS,EAAE,CAC1C;AACD,KAAI,iBAAiB,SAAS,EAC5B,OAAM,IAAI,MACR,CAAC,qDAAqD,EAAE,KAAK,UAC3D,iBACD,EAAE;CAGP,IAAIC,YAAsB,CAAE;AAC5B,KAAI,MAAM,MAAM,aAAa,EAC3B,YAAY,MAAM,IAAI,CAAC,SAAS,KAAK,SAAS,KAAK;UAC1C,MAAM,MAAM,iBAAiB,EACtC,YAAY,MAAM,IAAI,CAAC,SAAS,KAAK,KAAK;KAE1C,OAAM,IAAI,MACR;CAGJ,MAAM,kBAAkB,MAAM,OAAO,QAAQ;EAC3C,OAAO,6BAA6B,MAAM;EAC1C,YAAY,UAAU,KAAK,KAAK;CACjC,EAAC;CAEF,MAAM,cAAe,IAA0B,WAAW,EACxD,MAAM,CAAC,aAAc,EACtB,EAAC;CACF,MAAM,QAAQ,sBAAsB,cAClC;EACE,oBAAoB,OAAO,EACzB,kBAAkB,CAACC,UACjB,kBAAkB,MAAM,MAAM,CACjC,EAAC;EACF;EACA;EACA,sCAAsC,QAAQ,KAAK,EACjD,UACD,EAAC;CACH,GACD;EACE,MAAM;EACN;EACA,cAAc;CACf,EACF;AACD,QAAO;AACR"}

package/dist/agents/structured_chat/outputParser.cjs

@@ -0,0 +1,136 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_types = require('../types.cjs');
+const require_fix = require('../../output_parsers/fix.cjs');
+const require_prompt = require('./prompt.cjs');
+const __langchain_core_prompts = require_rolldown_runtime.__toESM(require("@langchain/core/prompts"));
+const __langchain_core_output_parsers = require_rolldown_runtime.__toESM(require("@langchain/core/output_parsers"));
+
+//#region src/agents/structured_chat/outputParser.ts
+/**
+* A class that provides a custom implementation for parsing the output of
+* a StructuredChatAgent action. It extends the `AgentActionOutputParser`
+* class and extracts the action and action input from the text output,
+* returning an `AgentAction` or `AgentFinish` object.
+*/
+var StructuredChatOutputParser = class extends require_types.AgentActionOutputParser {
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"structured_chat"
+	];
+	toolNames;
+	constructor(fields) {
+		super(...arguments);
+		this.toolNames = fields.toolNames;
+	}
+	/**
+	* Parses the given text and returns an `AgentAction` or `AgentFinish`
+	* object. If an `OutputFixingParser` is provided, it is used for parsing;
+	* otherwise, the base parser is used.
+	* @param text The text to parse.
+	* @param callbacks Optional callbacks for asynchronous operations.
+	* @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.
+	*/
+	async parse(text) {
+		try {
+			const regex = /```(?:json)?(.*)(```)/gs;
+			const actionMatch = regex.exec(text);
+			if (actionMatch === null) throw new __langchain_core_output_parsers.OutputParserException(`Could not parse an action. The agent action must be within a markdown code block, and "action" must be a provided tool or "Final Answer"`);
+			const response = JSON.parse(actionMatch[1].trim());
+			const { action, action_input } = response;
+			if (action === "Final Answer") return {
+				returnValues: { output: action_input },
+				log: text
+			};
+			return {
+				tool: action,
+				toolInput: action_input || {},
+				log: text
+			};
+		} catch (e) {
+			throw new __langchain_core_output_parsers.OutputParserException(`Failed to parse. Text: "${text}". Error: ${e}`);
+		}
+	}
+	/**
+	* Returns the format instructions for parsing the output of an agent
+	* action in the style of the StructuredChatAgent.
+	* @returns A string representing the format instructions.
+	*/
+	getFormatInstructions() {
+		return (0, __langchain_core_prompts.renderTemplate)(require_prompt.AGENT_ACTION_FORMAT_INSTRUCTIONS, "f-string", { tool_names: this.toolNames.join(", ") });
+	}
+};
+/**
+* A class that provides a wrapper around the `StructuredChatOutputParser`
+* and `OutputFixingParser` classes. It extends the
+* `AgentActionOutputParser` class and allows for retrying the output
+* parsing using the `OutputFixingParser` if it is provided.
+* @example
+* ```typescript
+* const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(
+*   new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0 }),
+*   {
+*     toolNames: ["calculator", "random-number-generator"],
+*   },
+* );
+* const result = await outputParser.parse(
+*  "What is a random number between 5 and 10 raised to the second power?"
+* );
+* ```
+*/
+var StructuredChatOutputParserWithRetries = class StructuredChatOutputParserWithRetries extends require_types.AgentActionOutputParser {
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"structured_chat"
+	];
+	baseParser;
+	outputFixingParser;
+	toolNames = [];
+	constructor(fields) {
+		super(fields);
+		this.toolNames = fields.toolNames ?? this.toolNames;
+		this.baseParser = fields?.baseParser ?? new StructuredChatOutputParser({ toolNames: this.toolNames });
+		this.outputFixingParser = fields?.outputFixingParser;
+	}
+	/**
+	* Parses the given text and returns an `AgentAction` or `AgentFinish`
+	* object. Throws an `OutputParserException` if the parsing fails.
+	* @param text The text to parse.
+	* @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.
+	*/
+	async parse(text, callbacks) {
+		if (this.outputFixingParser !== void 0) return this.outputFixingParser.parse(text, callbacks);
+		return this.baseParser.parse(text);
+	}
+	/**
+	* Returns the format instructions for parsing the output of an agent
+	* action in the style of the StructuredChatAgent.
+	* @returns A string representing the format instructions.
+	*/
+	getFormatInstructions() {
+		return (0, __langchain_core_prompts.renderTemplate)(require_prompt.FORMAT_INSTRUCTIONS, "f-string", { tool_names: this.toolNames.join(", ") });
+	}
+	/**
+	* Creates a new `StructuredChatOutputParserWithRetries` instance from a
+	* `BaseLanguageModel` and options. The options can include a base parser
+	* and tool names.
+	* @param llm A `BaseLanguageModel` instance.
+	* @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.
+	* @returns A new `StructuredChatOutputParserWithRetries` instance.
+	*/
+	static fromLLM(llm, options) {
+		const baseParser = options.baseParser ?? new StructuredChatOutputParser({ toolNames: options.toolNames ?? [] });
+		const outputFixingParser = require_fix.OutputFixingParser.fromLLM(llm, baseParser);
+		return new StructuredChatOutputParserWithRetries({
+			baseParser,
+			outputFixingParser,
+			toolNames: options.toolNames
+		});
+	}
+};
+
+//#endregion
+exports.StructuredChatOutputParser = StructuredChatOutputParser;
+exports.StructuredChatOutputParserWithRetries = StructuredChatOutputParserWithRetries;
+//# sourceMappingURL=outputParser.cjs.map

package/dist/agents/structured_chat/outputParser.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputParser.cjs","names":["AgentActionOutputParser","fields: { toolNames: string[] }","text: string","OutputParserException","AGENT_ACTION_FORMAT_INSTRUCTIONS","fields: StructuredChatOutputParserArgs","callbacks?: Callbacks","FORMAT_INSTRUCTIONS","llm: BaseLanguageModelInterface","options: Omit<StructuredChatOutputParserArgs, \"outputFixingParser\">","OutputFixingParser"],"sources":["../../../src/agents/structured_chat/outputParser.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { renderTemplate } from \"@langchain/core/prompts\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport {\n  AGENT_ACTION_FORMAT_INSTRUCTIONS,\n  FORMAT_INSTRUCTIONS,\n} from \"./prompt.js\";\nimport { OutputFixingParser } from \"../../output_parsers/fix.js\";\n\n/**\n * A class that provides a custom implementation for parsing the output of\n * a StructuredChatAgent action. It extends the `AgentActionOutputParser`\n * class and extracts the action and action input from the text output,\n * returning an `AgentAction` or `AgentFinish` object.\n */\nexport class StructuredChatOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"structured_chat\"];\n\n  private toolNames: string[];\n\n  constructor(fields: { toolNames: string[] }) {\n    super(...arguments);\n    this.toolNames = fields.toolNames;\n  }\n\n  /**\n   * Parses the given text and returns an `AgentAction` or `AgentFinish`\n   * object. If an `OutputFixingParser` is provided, it is used for parsing;\n   * otherwise, the base parser is used.\n   * @param text The text to parse.\n   * @param callbacks Optional callbacks for asynchronous operations.\n   * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n   */\n  async parse(text: string): Promise<AgentAction | AgentFinish> {\n    try {\n      const regex = /```(?:json)?(.*)(```)/gs;\n      const actionMatch = regex.exec(text);\n      if (actionMatch === null) {\n        throw new OutputParserException(\n          `Could not parse an action. The agent action must be within a markdown code block, and \"action\" must be a provided tool or \"Final Answer\"`\n        );\n      }\n      const response = JSON.parse(actionMatch[1].trim());\n      const { action, action_input } = response;\n\n      if (action === \"Final Answer\") {\n        return { returnValues: { output: action_input }, log: text };\n      }\n      return { tool: action, toolInput: action_input || {}, log: text };\n    } catch (e) {\n      throw new OutputParserException(\n        `Failed to parse. Text: \"${text}\". Error: ${e}`\n      );\n    }\n  }\n\n  /**\n   * Returns the format instructions for parsing the output of an agent\n   * action in the style of the StructuredChatAgent.\n   * @returns A string representing the format instructions.\n   */\n  getFormatInstructions(): string {\n    return renderTemplate(AGENT_ACTION_FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: this.toolNames.join(\", \"),\n    });\n  }\n}\n\n/**\n * An interface for the arguments used to construct a\n * `StructuredChatOutputParserWithRetries` instance.\n */\nexport interface StructuredChatOutputParserArgs {\n  baseParser?: StructuredChatOutputParser;\n  outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n  toolNames?: string[];\n}\n\n/**\n * A class that provides a wrapper around the `StructuredChatOutputParser`\n * and `OutputFixingParser` classes. It extends the\n * `AgentActionOutputParser` class and allows for retrying the output\n * parsing using the `OutputFixingParser` if it is provided.\n * @example\n * ```typescript\n * const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     toolNames: [\"calculator\", \"random-number-generator\"],\n *   },\n * );\n * const result = await outputParser.parse(\n *  \"What is a random number between 5 and 10 raised to the second power?\"\n * );\n * ```\n */\nexport class StructuredChatOutputParserWithRetries extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"structured_chat\"];\n\n  private baseParser: StructuredChatOutputParser;\n\n  private outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n\n  private toolNames: string[] = [];\n\n  constructor(fields: StructuredChatOutputParserArgs) {\n    super(fields);\n    this.toolNames = fields.toolNames ?? this.toolNames;\n    this.baseParser =\n      fields?.baseParser ??\n      new StructuredChatOutputParser({ toolNames: this.toolNames });\n    this.outputFixingParser = fields?.outputFixingParser;\n  }\n\n  /**\n   * Parses the given text and returns an `AgentAction` or `AgentFinish`\n   * object. Throws an `OutputParserException` if the parsing fails.\n   * @param text The text to parse.\n   * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n   */\n  async parse(\n    text: string,\n    callbacks?: Callbacks\n  ): Promise<AgentAction | AgentFinish> {\n    if (this.outputFixingParser !== undefined) {\n      return this.outputFixingParser.parse(text, callbacks);\n    }\n    return this.baseParser.parse(text);\n  }\n\n  /**\n   * Returns the format instructions for parsing the output of an agent\n   * action in the style of the StructuredChatAgent.\n   * @returns A string representing the format instructions.\n   */\n  getFormatInstructions(): string {\n    return renderTemplate(FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: this.toolNames.join(\", \"),\n    });\n  }\n\n  /**\n   * Creates a new `StructuredChatOutputParserWithRetries` instance from a\n   * `BaseLanguageModel` and options. The options can include a base parser\n   * and tool names.\n   * @param llm A `BaseLanguageModel` instance.\n   * @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.\n   * @returns A new `StructuredChatOutputParserWithRetries` instance.\n   */\n  static fromLLM(\n    llm: BaseLanguageModelInterface,\n    options: Omit<StructuredChatOutputParserArgs, \"outputFixingParser\">\n  ): StructuredChatOutputParserWithRetries {\n    const baseParser =\n      options.baseParser ??\n      new StructuredChatOutputParser({ toolNames: options.toolNames ?? [] });\n    const outputFixingParser = OutputFixingParser.fromLLM(llm, baseParser);\n    return new StructuredChatOutputParserWithRetries({\n      baseParser,\n      outputFixingParser,\n      toolNames: options.toolNames,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAkBA,IAAa,6BAAb,cAAgDA,sCAAwB;CACtE,eAAe;EAAC;EAAa;EAAU;CAAkB;CAEzD,AAAQ;CAER,YAAYC,QAAiC;EAC3C,MAAM,GAAG,UAAU;EACnB,KAAK,YAAY,OAAO;CACzB;;;;;;;;;CAUD,MAAM,MAAMC,MAAkD;AAC5D,MAAI;GACF,MAAM,QAAQ;GACd,MAAM,cAAc,MAAM,KAAK,KAAK;AACpC,OAAI,gBAAgB,KAClB,OAAM,IAAIC,sDACR,CAAC,wIAAwI,CAAC;GAG9I,MAAM,WAAW,KAAK,MAAM,YAAY,GAAG,MAAM,CAAC;GAClD,MAAM,EAAE,QAAQ,cAAc,GAAG;AAEjC,OAAI,WAAW,eACb,QAAO;IAAE,cAAc,EAAE,QAAQ,aAAc;IAAE,KAAK;GAAM;AAE9D,UAAO;IAAE,MAAM;IAAQ,WAAW,gBAAgB,CAAE;IAAE,KAAK;GAAM;EAClE,SAAQ,GAAG;AACV,SAAM,IAAIA,sDACR,CAAC,wBAAwB,EAAE,KAAK,UAAU,EAAE,GAAG;EAElD;CACF;;;;;;CAOD,wBAAgC;AAC9B,sDAAsBC,iDAAkC,YAAY,EAClE,YAAY,KAAK,UAAU,KAAK,KAAK,CACtC,EAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;AA8BD,IAAa,wCAAb,MAAa,8CAA8CJ,sCAAwB;CACjF,eAAe;EAAC;EAAa;EAAU;CAAkB;CAEzD,AAAQ;CAER,AAAQ;CAER,AAAQ,YAAsB,CAAE;CAEhC,YAAYK,QAAwC;EAClD,MAAM,OAAO;EACb,KAAK,YAAY,OAAO,aAAa,KAAK;EAC1C,KAAK,aACH,QAAQ,cACR,IAAI,2BAA2B,EAAE,WAAW,KAAK,UAAW;EAC9D,KAAK,qBAAqB,QAAQ;CACnC;;;;;;;CAQD,MAAM,MACJH,MACAI,WACoC;AACpC,MAAI,KAAK,uBAAuB,OAC9B,QAAO,KAAK,mBAAmB,MAAM,MAAM,UAAU;AAEvD,SAAO,KAAK,WAAW,MAAM,KAAK;CACnC;;;;;;CAOD,wBAAgC;AAC9B,sDAAsBC,oCAAqB,YAAY,EACrD,YAAY,KAAK,UAAU,KAAK,KAAK,CACtC,EAAC;CACH;;;;;;;;;CAUD,OAAO,QACLC,KACAC,SACuC;EACvC,MAAM,aACJ,QAAQ,cACR,IAAI,2BAA2B,EAAE,WAAW,QAAQ,aAAa,CAAE,EAAE;EACvE,MAAM,qBAAqBC,+BAAmB,QAAQ,KAAK,WAAW;AACtE,SAAO,IAAI,sCAAsC;GAC/C;GACA;GACA,WAAW,QAAQ;EACpB;CACF;AACF"}

package/dist/agents/structured_chat/outputParser.d.cts

@@ -0,0 +1,95 @@
+import { AgentActionOutputParser } from "../types.cjs";
+import { OutputFixingParser } from "../../output_parsers/fix.cjs";
+import { AgentAction, AgentFinish } from "@langchain/core/agents";
+import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import { Callbacks } from "@langchain/core/callbacks/manager";
+
+//#region src/agents/structured_chat/outputParser.d.ts
+
+/**
+ * A class that provides a custom implementation for parsing the output of
+ * a StructuredChatAgent action. It extends the `AgentActionOutputParser`
+ * class and extracts the action and action input from the text output,
+ * returning an `AgentAction` or `AgentFinish` object.
+ */
+declare class StructuredChatOutputParser extends AgentActionOutputParser {
+  lc_namespace: string[];
+  private toolNames;
+  constructor(fields: {
+    toolNames: string[];
+  });
+  /**
+   * Parses the given text and returns an `AgentAction` or `AgentFinish`
+   * object. If an `OutputFixingParser` is provided, it is used for parsing;
+   * otherwise, the base parser is used.
+   * @param text The text to parse.
+   * @param callbacks Optional callbacks for asynchronous operations.
+   * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.
+   */
+  parse(text: string): Promise<AgentAction | AgentFinish>;
+  /**
+   * Returns the format instructions for parsing the output of an agent
+   * action in the style of the StructuredChatAgent.
+   * @returns A string representing the format instructions.
+   */
+  getFormatInstructions(): string;
+}
+/**
+ * An interface for the arguments used to construct a
+ * `StructuredChatOutputParserWithRetries` instance.
+ */
+interface StructuredChatOutputParserArgs {
+  baseParser?: StructuredChatOutputParser;
+  outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;
+  toolNames?: string[];
+}
+/**
+ * A class that provides a wrapper around the `StructuredChatOutputParser`
+ * and `OutputFixingParser` classes. It extends the
+ * `AgentActionOutputParser` class and allows for retrying the output
+ * parsing using the `OutputFixingParser` if it is provided.
+ * @example
+ * ```typescript
+ * const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(
+ *   new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0 }),
+ *   {
+ *     toolNames: ["calculator", "random-number-generator"],
+ *   },
+ * );
+ * const result = await outputParser.parse(
+ *  "What is a random number between 5 and 10 raised to the second power?"
+ * );
+ * ```
+ */
+declare class StructuredChatOutputParserWithRetries extends AgentActionOutputParser {
+  lc_namespace: string[];
+  private baseParser;
+  private outputFixingParser?;
+  private toolNames;
+  constructor(fields: StructuredChatOutputParserArgs);
+  /**
+   * Parses the given text and returns an `AgentAction` or `AgentFinish`
+   * object. Throws an `OutputParserException` if the parsing fails.
+   * @param text The text to parse.
+   * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.
+   */
+  parse(text: string, callbacks?: Callbacks): Promise<AgentAction | AgentFinish>;
+  /**
+   * Returns the format instructions for parsing the output of an agent
+   * action in the style of the StructuredChatAgent.
+   * @returns A string representing the format instructions.
+   */
+  getFormatInstructions(): string;
+  /**
+   * Creates a new `StructuredChatOutputParserWithRetries` instance from a
+   * `BaseLanguageModel` and options. The options can include a base parser
+   * and tool names.
+   * @param llm A `BaseLanguageModel` instance.
+   * @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.
+   * @returns A new `StructuredChatOutputParserWithRetries` instance.
+   */
+  static fromLLM(llm: BaseLanguageModelInterface, options: Omit<StructuredChatOutputParserArgs, "outputFixingParser">): StructuredChatOutputParserWithRetries;
+}
+//#endregion
+export { StructuredChatOutputParser, StructuredChatOutputParserArgs, StructuredChatOutputParserWithRetries };
+//# sourceMappingURL=outputParser.d.cts.map

package/dist/agents/structured_chat/outputParser.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputParser.d.cts","names":["BaseLanguageModelInterface","Callbacks","AgentAction","AgentFinish","AgentActionOutputParser","OutputFixingParser","StructuredChatOutputParser","Promise","StructuredChatOutputParserArgs","StructuredChatOutputParserWithRetries","Omit"],"sources":["../../../src/agents/structured_chat/outputParser.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport { OutputFixingParser } from \"../../output_parsers/fix.js\";\n/**\n * A class that provides a custom implementation for parsing the output of\n * a StructuredChatAgent action. It extends the `AgentActionOutputParser`\n * class and extracts the action and action input from the text output,\n * returning an `AgentAction` or `AgentFinish` object.\n */\nexport declare class StructuredChatOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private toolNames;\n    constructor(fields: {\n        toolNames: string[];\n    });\n    /**\n     * Parses the given text and returns an `AgentAction` or `AgentFinish`\n     * object. If an `OutputFixingParser` is provided, it is used for parsing;\n     * otherwise, the base parser is used.\n     * @param text The text to parse.\n     * @param callbacks Optional callbacks for asynchronous operations.\n     * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n     */\n    parse(text: string): Promise<AgentAction | AgentFinish>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the StructuredChatAgent.\n     * @returns A string representing the format instructions.\n     */\n    getFormatInstructions(): string;\n}\n/**\n * An interface for the arguments used to construct a\n * `StructuredChatOutputParserWithRetries` instance.\n */\nexport interface StructuredChatOutputParserArgs {\n    baseParser?: StructuredChatOutputParser;\n    outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n    toolNames?: string[];\n}\n/**\n * A class that provides a wrapper around the `StructuredChatOutputParser`\n * and `OutputFixingParser` classes. It extends the\n * `AgentActionOutputParser` class and allows for retrying the output\n * parsing using the `OutputFixingParser` if it is provided.\n * @example\n * ```typescript\n * const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     toolNames: [\"calculator\", \"random-number-generator\"],\n *   },\n * );\n * const result = await outputParser.parse(\n *  \"What is a random number between 5 and 10 raised to the second power?\"\n * );\n * ```\n */\nexport declare class StructuredChatOutputParserWithRetries extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private baseParser;\n    private outputFixingParser?;\n    private toolNames;\n    constructor(fields: StructuredChatOutputParserArgs);\n    /**\n     * Parses the given text and returns an `AgentAction` or `AgentFinish`\n     * object. Throws an `OutputParserException` if the parsing fails.\n     * @param text The text to parse.\n     * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n     */\n    parse(text: string, callbacks?: Callbacks): Promise<AgentAction | AgentFinish>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the StructuredChatAgent.\n     * @returns A string representing the format instructions.\n     */\n    getFormatInstructions(): string;\n    /**\n     * Creates a new `StructuredChatOutputParserWithRetries` instance from a\n     * `BaseLanguageModel` and options. The options can include a base parser\n     * and tool names.\n     * @param llm A `BaseLanguageModel` instance.\n     * @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.\n     * @returns A new `StructuredChatOutputParserWithRetries` instance.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, options: Omit<StructuredChatOutputParserArgs, \"outputFixingParser\">): StructuredChatOutputParserWithRetries;\n}\n"],"mappings":";;;;;;;;;;AAWA;;;;AAcyBO,cAdJD,0BAAAA,SAAmCF,uBAAAA,CAc/BG;EAAO,YAdwBH,EAAAA,MAAAA,EAAAA;EAAuB,QAAA,SAAA;EA0B9DI,WAAAA,CAAAA,MAAAA,EAAAA;IAA8B,SAAA,EAAA,MAAA,EAAA;EAAA,CAAA;EACJ;;;AACA;AAqB3C;;;;EAY6C,KAAWN,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EA/C/BK,OA+C+BL,CA/CvBA,WA+CuBA,GA/CTC,WA+CSD,CAAAA;EAAW;;;;;EAeF,qBAAyDO,CAAAA,CAAAA,EAAAA,MAAAA;;AA3BhC;;;;UAvBzED,8BAAAA;eACAF;uBACQD,mBAAmBH,cAAcC;;;;;;;;;;;;;;;;;;;;;cAqBrCM,qCAAAA,SAA8CL,uBAAAA;;;;;sBAK3CI;;;;;;;kCAOYP,YAAYM,QAAQL,cAAcC;;;;;;;;;;;;;;;sBAe9CH,qCAAqCU,KAAKF,wDAAwDC"}

package/dist/agents/structured_chat/outputParser.d.ts

@@ -0,0 +1,95 @@
+import { AgentActionOutputParser } from "../types.js";
+import { OutputFixingParser } from "../../output_parsers/fix.js";
+import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import { Callbacks } from "@langchain/core/callbacks/manager";
+import { AgentAction, AgentFinish } from "@langchain/core/agents";
+
+//#region src/agents/structured_chat/outputParser.d.ts
+
+/**
+ * A class that provides a custom implementation for parsing the output of
+ * a StructuredChatAgent action. It extends the `AgentActionOutputParser`
+ * class and extracts the action and action input from the text output,
+ * returning an `AgentAction` or `AgentFinish` object.
+ */
+declare class StructuredChatOutputParser extends AgentActionOutputParser {
+  lc_namespace: string[];
+  private toolNames;
+  constructor(fields: {
+    toolNames: string[];
+  });
+  /**
+   * Parses the given text and returns an `AgentAction` or `AgentFinish`
+   * object. If an `OutputFixingParser` is provided, it is used for parsing;
+   * otherwise, the base parser is used.
+   * @param text The text to parse.
+   * @param callbacks Optional callbacks for asynchronous operations.
+   * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.
+   */
+  parse(text: string): Promise<AgentAction | AgentFinish>;
+  /**
+   * Returns the format instructions for parsing the output of an agent
+   * action in the style of the StructuredChatAgent.
+   * @returns A string representing the format instructions.
+   */
+  getFormatInstructions(): string;
+}
+/**
+ * An interface for the arguments used to construct a
+ * `StructuredChatOutputParserWithRetries` instance.
+ */
+interface StructuredChatOutputParserArgs {
+  baseParser?: StructuredChatOutputParser;
+  outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;
+  toolNames?: string[];
+}
+/**
+ * A class that provides a wrapper around the `StructuredChatOutputParser`
+ * and `OutputFixingParser` classes. It extends the
+ * `AgentActionOutputParser` class and allows for retrying the output
+ * parsing using the `OutputFixingParser` if it is provided.
+ * @example
+ * ```typescript
+ * const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(
+ *   new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0 }),
+ *   {
+ *     toolNames: ["calculator", "random-number-generator"],
+ *   },
+ * );
+ * const result = await outputParser.parse(
+ *  "What is a random number between 5 and 10 raised to the second power?"
+ * );
+ * ```
+ */
+declare class StructuredChatOutputParserWithRetries extends AgentActionOutputParser {
+  lc_namespace: string[];
+  private baseParser;
+  private outputFixingParser?;
+  private toolNames;
+  constructor(fields: StructuredChatOutputParserArgs);
+  /**
+   * Parses the given text and returns an `AgentAction` or `AgentFinish`
+   * object. Throws an `OutputParserException` if the parsing fails.
+   * @param text The text to parse.
+   * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.
+   */
+  parse(text: string, callbacks?: Callbacks): Promise<AgentAction | AgentFinish>;
+  /**
+   * Returns the format instructions for parsing the output of an agent
+   * action in the style of the StructuredChatAgent.
+   * @returns A string representing the format instructions.
+   */
+  getFormatInstructions(): string;
+  /**
+   * Creates a new `StructuredChatOutputParserWithRetries` instance from a
+   * `BaseLanguageModel` and options. The options can include a base parser
+   * and tool names.
+   * @param llm A `BaseLanguageModel` instance.
+   * @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.
+   * @returns A new `StructuredChatOutputParserWithRetries` instance.
+   */
+  static fromLLM(llm: BaseLanguageModelInterface, options: Omit<StructuredChatOutputParserArgs, "outputFixingParser">): StructuredChatOutputParserWithRetries;
+}
+//#endregion
+export { StructuredChatOutputParser, StructuredChatOutputParserArgs, StructuredChatOutputParserWithRetries };
+//# sourceMappingURL=outputParser.d.ts.map

package/dist/agents/structured_chat/outputParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputParser.d.ts","names":["BaseLanguageModelInterface","Callbacks","AgentAction","AgentFinish","AgentActionOutputParser","OutputFixingParser","StructuredChatOutputParser","Promise","StructuredChatOutputParserArgs","StructuredChatOutputParserWithRetries","Omit"],"sources":["../../../src/agents/structured_chat/outputParser.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport { OutputFixingParser } from \"../../output_parsers/fix.js\";\n/**\n * A class that provides a custom implementation for parsing the output of\n * a StructuredChatAgent action. It extends the `AgentActionOutputParser`\n * class and extracts the action and action input from the text output,\n * returning an `AgentAction` or `AgentFinish` object.\n */\nexport declare class StructuredChatOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private toolNames;\n    constructor(fields: {\n        toolNames: string[];\n    });\n    /**\n     * Parses the given text and returns an `AgentAction` or `AgentFinish`\n     * object. If an `OutputFixingParser` is provided, it is used for parsing;\n     * otherwise, the base parser is used.\n     * @param text The text to parse.\n     * @param callbacks Optional callbacks for asynchronous operations.\n     * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n     */\n    parse(text: string): Promise<AgentAction | AgentFinish>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the StructuredChatAgent.\n     * @returns A string representing the format instructions.\n     */\n    getFormatInstructions(): string;\n}\n/**\n * An interface for the arguments used to construct a\n * `StructuredChatOutputParserWithRetries` instance.\n */\nexport interface StructuredChatOutputParserArgs {\n    baseParser?: StructuredChatOutputParser;\n    outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n    toolNames?: string[];\n}\n/**\n * A class that provides a wrapper around the `StructuredChatOutputParser`\n * and `OutputFixingParser` classes. It extends the\n * `AgentActionOutputParser` class and allows for retrying the output\n * parsing using the `OutputFixingParser` if it is provided.\n * @example\n * ```typescript\n * const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     toolNames: [\"calculator\", \"random-number-generator\"],\n *   },\n * );\n * const result = await outputParser.parse(\n *  \"What is a random number between 5 and 10 raised to the second power?\"\n * );\n * ```\n */\nexport declare class StructuredChatOutputParserWithRetries extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private baseParser;\n    private outputFixingParser?;\n    private toolNames;\n    constructor(fields: StructuredChatOutputParserArgs);\n    /**\n     * Parses the given text and returns an `AgentAction` or `AgentFinish`\n     * object. Throws an `OutputParserException` if the parsing fails.\n     * @param text The text to parse.\n     * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n     */\n    parse(text: string, callbacks?: Callbacks): Promise<AgentAction | AgentFinish>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the StructuredChatAgent.\n     * @returns A string representing the format instructions.\n     */\n    getFormatInstructions(): string;\n    /**\n     * Creates a new `StructuredChatOutputParserWithRetries` instance from a\n     * `BaseLanguageModel` and options. The options can include a base parser\n     * and tool names.\n     * @param llm A `BaseLanguageModel` instance.\n     * @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.\n     * @returns A new `StructuredChatOutputParserWithRetries` instance.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, options: Omit<StructuredChatOutputParserArgs, \"outputFixingParser\">): StructuredChatOutputParserWithRetries;\n}\n"],"mappings":";;;;;;;;;;AAWA;;;;AAcyBO,cAdJD,0BAAAA,SAAmCF,uBAAAA,CAc/BG;EAAO,YAdwBH,EAAAA,MAAAA,EAAAA;EAAuB,QAAA,SAAA;EA0B9DI,WAAAA,CAAAA,MAAAA,EAAAA;IAA8B,SAAA,EAAA,MAAA,EAAA;EAAA,CAAA;EACJ;;;AACA;AAqB3C;;;;EAY6C,KAAWN,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EA/C/BK,OA+C+BL,CA/CvBA,WA+CuBA,GA/CTC,WA+CSD,CAAAA;EAAW;;;;;EAeF,qBAAyDO,CAAAA,CAAAA,EAAAA,MAAAA;;AA3BhC;;;;UAvBzED,8BAAAA;eACAF;uBACQD,mBAAmBH,cAAcC;;;;;;;;;;;;;;;;;;;;;cAqBrCM,qCAAAA,SAA8CL,uBAAAA;;;;;sBAK3CI;;;;;;;kCAOYP,YAAYM,QAAQL,cAAcC;;;;;;;;;;;;;;;sBAe9CH,qCAAqCU,KAAKF,wDAAwDC"}

package/dist/agents/structured_chat/outputParser.js

@@ -0,0 +1,134 @@
+import { AgentActionOutputParser } from "../types.js";
+import { OutputFixingParser } from "../../output_parsers/fix.js";
+import { AGENT_ACTION_FORMAT_INSTRUCTIONS, FORMAT_INSTRUCTIONS } from "./prompt.js";
+import { renderTemplate } from "@langchain/core/prompts";
+import { OutputParserException } from "@langchain/core/output_parsers";
+
+//#region src/agents/structured_chat/outputParser.ts
+/**
+* A class that provides a custom implementation for parsing the output of
+* a StructuredChatAgent action. It extends the `AgentActionOutputParser`
+* class and extracts the action and action input from the text output,
+* returning an `AgentAction` or `AgentFinish` object.
+*/
+var StructuredChatOutputParser = class extends AgentActionOutputParser {
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"structured_chat"
+	];
+	toolNames;
+	constructor(fields) {
+		super(...arguments);
+		this.toolNames = fields.toolNames;
+	}
+	/**
+	* Parses the given text and returns an `AgentAction` or `AgentFinish`
+	* object. If an `OutputFixingParser` is provided, it is used for parsing;
+	* otherwise, the base parser is used.
+	* @param text The text to parse.
+	* @param callbacks Optional callbacks for asynchronous operations.
+	* @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.
+	*/
+	async parse(text) {
+		try {
+			const regex = /```(?:json)?(.*)(```)/gs;
+			const actionMatch = regex.exec(text);
+			if (actionMatch === null) throw new OutputParserException(`Could not parse an action. The agent action must be within a markdown code block, and "action" must be a provided tool or "Final Answer"`);
+			const response = JSON.parse(actionMatch[1].trim());
+			const { action, action_input } = response;
+			if (action === "Final Answer") return {
+				returnValues: { output: action_input },
+				log: text
+			};
+			return {
+				tool: action,
+				toolInput: action_input || {},
+				log: text
+			};
+		} catch (e) {
+			throw new OutputParserException(`Failed to parse. Text: "${text}". Error: ${e}`);
+		}
+	}
+	/**
+	* Returns the format instructions for parsing the output of an agent
+	* action in the style of the StructuredChatAgent.
+	* @returns A string representing the format instructions.
+	*/
+	getFormatInstructions() {
+		return renderTemplate(AGENT_ACTION_FORMAT_INSTRUCTIONS, "f-string", { tool_names: this.toolNames.join(", ") });
+	}
+};
+/**
+* A class that provides a wrapper around the `StructuredChatOutputParser`
+* and `OutputFixingParser` classes. It extends the
+* `AgentActionOutputParser` class and allows for retrying the output
+* parsing using the `OutputFixingParser` if it is provided.
+* @example
+* ```typescript
+* const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(
+*   new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0 }),
+*   {
+*     toolNames: ["calculator", "random-number-generator"],
+*   },
+* );
+* const result = await outputParser.parse(
+*  "What is a random number between 5 and 10 raised to the second power?"
+* );
+* ```
+*/
+var StructuredChatOutputParserWithRetries = class StructuredChatOutputParserWithRetries extends AgentActionOutputParser {
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"structured_chat"
+	];
+	baseParser;
+	outputFixingParser;
+	toolNames = [];
+	constructor(fields) {
+		super(fields);
+		this.toolNames = fields.toolNames ?? this.toolNames;
+		this.baseParser = fields?.baseParser ?? new StructuredChatOutputParser({ toolNames: this.toolNames });
+		this.outputFixingParser = fields?.outputFixingParser;
+	}
+	/**
+	* Parses the given text and returns an `AgentAction` or `AgentFinish`
+	* object. Throws an `OutputParserException` if the parsing fails.
+	* @param text The text to parse.
+	* @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.
+	*/
+	async parse(text, callbacks) {
+		if (this.outputFixingParser !== void 0) return this.outputFixingParser.parse(text, callbacks);
+		return this.baseParser.parse(text);
+	}
+	/**
+	* Returns the format instructions for parsing the output of an agent
+	* action in the style of the StructuredChatAgent.
+	* @returns A string representing the format instructions.
+	*/
+	getFormatInstructions() {
+		return renderTemplate(FORMAT_INSTRUCTIONS, "f-string", { tool_names: this.toolNames.join(", ") });
+	}
+	/**
+	* Creates a new `StructuredChatOutputParserWithRetries` instance from a
+	* `BaseLanguageModel` and options. The options can include a base parser
+	* and tool names.
+	* @param llm A `BaseLanguageModel` instance.
+	* @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.
+	* @returns A new `StructuredChatOutputParserWithRetries` instance.
+	*/
+	static fromLLM(llm, options) {
+		const baseParser = options.baseParser ?? new StructuredChatOutputParser({ toolNames: options.toolNames ?? [] });
+		const outputFixingParser = OutputFixingParser.fromLLM(llm, baseParser);
+		return new StructuredChatOutputParserWithRetries({
+			baseParser,
+			outputFixingParser,
+			toolNames: options.toolNames
+		});
+	}
+};
+
+//#endregion
+export { StructuredChatOutputParser, StructuredChatOutputParserWithRetries };
+//# sourceMappingURL=outputParser.js.map

package/dist/agents/structured_chat/outputParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputParser.js","names":["fields: { toolNames: string[] }","text: string","fields: StructuredChatOutputParserArgs","callbacks?: Callbacks","llm: BaseLanguageModelInterface","options: Omit<StructuredChatOutputParserArgs, \"outputFixingParser\">"],"sources":["../../../src/agents/structured_chat/outputParser.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { renderTemplate } from \"@langchain/core/prompts\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport {\n  AGENT_ACTION_FORMAT_INSTRUCTIONS,\n  FORMAT_INSTRUCTIONS,\n} from \"./prompt.js\";\nimport { OutputFixingParser } from \"../../output_parsers/fix.js\";\n\n/**\n * A class that provides a custom implementation for parsing the output of\n * a StructuredChatAgent action. It extends the `AgentActionOutputParser`\n * class and extracts the action and action input from the text output,\n * returning an `AgentAction` or `AgentFinish` object.\n */\nexport class StructuredChatOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"structured_chat\"];\n\n  private toolNames: string[];\n\n  constructor(fields: { toolNames: string[] }) {\n    super(...arguments);\n    this.toolNames = fields.toolNames;\n  }\n\n  /**\n   * Parses the given text and returns an `AgentAction` or `AgentFinish`\n   * object. If an `OutputFixingParser` is provided, it is used for parsing;\n   * otherwise, the base parser is used.\n   * @param text The text to parse.\n   * @param callbacks Optional callbacks for asynchronous operations.\n   * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n   */\n  async parse(text: string): Promise<AgentAction | AgentFinish> {\n    try {\n      const regex = /```(?:json)?(.*)(```)/gs;\n      const actionMatch = regex.exec(text);\n      if (actionMatch === null) {\n        throw new OutputParserException(\n          `Could not parse an action. The agent action must be within a markdown code block, and \"action\" must be a provided tool or \"Final Answer\"`\n        );\n      }\n      const response = JSON.parse(actionMatch[1].trim());\n      const { action, action_input } = response;\n\n      if (action === \"Final Answer\") {\n        return { returnValues: { output: action_input }, log: text };\n      }\n      return { tool: action, toolInput: action_input || {}, log: text };\n    } catch (e) {\n      throw new OutputParserException(\n        `Failed to parse. Text: \"${text}\". Error: ${e}`\n      );\n    }\n  }\n\n  /**\n   * Returns the format instructions for parsing the output of an agent\n   * action in the style of the StructuredChatAgent.\n   * @returns A string representing the format instructions.\n   */\n  getFormatInstructions(): string {\n    return renderTemplate(AGENT_ACTION_FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: this.toolNames.join(\", \"),\n    });\n  }\n}\n\n/**\n * An interface for the arguments used to construct a\n * `StructuredChatOutputParserWithRetries` instance.\n */\nexport interface StructuredChatOutputParserArgs {\n  baseParser?: StructuredChatOutputParser;\n  outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n  toolNames?: string[];\n}\n\n/**\n * A class that provides a wrapper around the `StructuredChatOutputParser`\n * and `OutputFixingParser` classes. It extends the\n * `AgentActionOutputParser` class and allows for retrying the output\n * parsing using the `OutputFixingParser` if it is provided.\n * @example\n * ```typescript\n * const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     toolNames: [\"calculator\", \"random-number-generator\"],\n *   },\n * );\n * const result = await outputParser.parse(\n *  \"What is a random number between 5 and 10 raised to the second power?\"\n * );\n * ```\n */\nexport class StructuredChatOutputParserWithRetries extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"structured_chat\"];\n\n  private baseParser: StructuredChatOutputParser;\n\n  private outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n\n  private toolNames: string[] = [];\n\n  constructor(fields: StructuredChatOutputParserArgs) {\n    super(fields);\n    this.toolNames = fields.toolNames ?? this.toolNames;\n    this.baseParser =\n      fields?.baseParser ??\n      new StructuredChatOutputParser({ toolNames: this.toolNames });\n    this.outputFixingParser = fields?.outputFixingParser;\n  }\n\n  /**\n   * Parses the given text and returns an `AgentAction` or `AgentFinish`\n   * object. Throws an `OutputParserException` if the parsing fails.\n   * @param text The text to parse.\n   * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n   */\n  async parse(\n    text: string,\n    callbacks?: Callbacks\n  ): Promise<AgentAction | AgentFinish> {\n    if (this.outputFixingParser !== undefined) {\n      return this.outputFixingParser.parse(text, callbacks);\n    }\n    return this.baseParser.parse(text);\n  }\n\n  /**\n   * Returns the format instructions for parsing the output of an agent\n   * action in the style of the StructuredChatAgent.\n   * @returns A string representing the format instructions.\n   */\n  getFormatInstructions(): string {\n    return renderTemplate(FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: this.toolNames.join(\", \"),\n    });\n  }\n\n  /**\n   * Creates a new `StructuredChatOutputParserWithRetries` instance from a\n   * `BaseLanguageModel` and options. The options can include a base parser\n   * and tool names.\n   * @param llm A `BaseLanguageModel` instance.\n   * @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.\n   * @returns A new `StructuredChatOutputParserWithRetries` instance.\n   */\n  static fromLLM(\n    llm: BaseLanguageModelInterface,\n    options: Omit<StructuredChatOutputParserArgs, \"outputFixingParser\">\n  ): StructuredChatOutputParserWithRetries {\n    const baseParser =\n      options.baseParser ??\n      new StructuredChatOutputParser({ toolNames: options.toolNames ?? [] });\n    const outputFixingParser = OutputFixingParser.fromLLM(llm, baseParser);\n    return new StructuredChatOutputParserWithRetries({\n      baseParser,\n      outputFixingParser,\n      toolNames: options.toolNames,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAkBA,IAAa,6BAAb,cAAgD,wBAAwB;CACtE,eAAe;EAAC;EAAa;EAAU;CAAkB;CAEzD,AAAQ;CAER,YAAYA,QAAiC;EAC3C,MAAM,GAAG,UAAU;EACnB,KAAK,YAAY,OAAO;CACzB;;;;;;;;;CAUD,MAAM,MAAMC,MAAkD;AAC5D,MAAI;GACF,MAAM,QAAQ;GACd,MAAM,cAAc,MAAM,KAAK,KAAK;AACpC,OAAI,gBAAgB,KAClB,OAAM,IAAI,sBACR,CAAC,wIAAwI,CAAC;GAG9I,MAAM,WAAW,KAAK,MAAM,YAAY,GAAG,MAAM,CAAC;GAClD,MAAM,EAAE,QAAQ,cAAc,GAAG;AAEjC,OAAI,WAAW,eACb,QAAO;IAAE,cAAc,EAAE,QAAQ,aAAc;IAAE,KAAK;GAAM;AAE9D,UAAO;IAAE,MAAM;IAAQ,WAAW,gBAAgB,CAAE;IAAE,KAAK;GAAM;EAClE,SAAQ,GAAG;AACV,SAAM,IAAI,sBACR,CAAC,wBAAwB,EAAE,KAAK,UAAU,EAAE,GAAG;EAElD;CACF;;;;;;CAOD,wBAAgC;AAC9B,SAAO,eAAe,kCAAkC,YAAY,EAClE,YAAY,KAAK,UAAU,KAAK,KAAK,CACtC,EAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;AA8BD,IAAa,wCAAb,MAAa,8CAA8C,wBAAwB;CACjF,eAAe;EAAC;EAAa;EAAU;CAAkB;CAEzD,AAAQ;CAER,AAAQ;CAER,AAAQ,YAAsB,CAAE;CAEhC,YAAYC,QAAwC;EAClD,MAAM,OAAO;EACb,KAAK,YAAY,OAAO,aAAa,KAAK;EAC1C,KAAK,aACH,QAAQ,cACR,IAAI,2BAA2B,EAAE,WAAW,KAAK,UAAW;EAC9D,KAAK,qBAAqB,QAAQ;CACnC;;;;;;;CAQD,MAAM,MACJD,MACAE,WACoC;AACpC,MAAI,KAAK,uBAAuB,OAC9B,QAAO,KAAK,mBAAmB,MAAM,MAAM,UAAU;AAEvD,SAAO,KAAK,WAAW,MAAM,KAAK;CACnC;;;;;;CAOD,wBAAgC;AAC9B,SAAO,eAAe,qBAAqB,YAAY,EACrD,YAAY,KAAK,UAAU,KAAK,KAAK,CACtC,EAAC;CACH;;;;;;;;;CAUD,OAAO,QACLC,KACAC,SACuC;EACvC,MAAM,aACJ,QAAQ,cACR,IAAI,2BAA2B,EAAE,WAAW,QAAQ,aAAa,CAAE,EAAE;EACvE,MAAM,qBAAqB,mBAAmB,QAAQ,KAAK,WAAW;AACtE,SAAO,IAAI,sCAAsC;GAC/C;GACA;GACA,WAAW,QAAQ;EACpB;CACF;AACF"}

package/dist/agents/structured_chat/prompt.cjs

@@ -0,0 +1,68 @@
+
+//#region src/agents/structured_chat/prompt.ts
+const PREFIX = `Answer the following questions truthfully and as best you can.`;
+const AGENT_ACTION_FORMAT_INSTRUCTIONS = `Output a JSON markdown code snippet containing a valid JSON blob (denoted below by $JSON_BLOB).
+This $JSON_BLOB must have a "action" key (with the name of the tool to use) and an "action_input" key (tool input).
+
+Valid "action" values: "Final Answer" (which you must use when giving your final response to the user), or one of [{tool_names}].
+
+The $JSON_BLOB must be valid, parseable JSON and only contain a SINGLE action. Here is an example of an acceptable output:
+
+\`\`\`json
+{{
+  "action": $TOOL_NAME,
+  "action_input": $INPUT
+}}
+\`\`\`
+
+Remember to include the surrounding markdown code snippet delimiters (begin with "\`\`\`" json and close with "\`\`\`")!
+`;
+const FORMAT_INSTRUCTIONS = `You have access to the following tools.
+You must format your inputs to these tools to match their "JSON schema" definitions below.
+
+"JSON Schema" is a declarative language that allows you to annotate and validate JSON documents.
+
+For example, the example "JSON Schema" instance {{"properties": {{"foo": {{"description": "a list of test words", "type": "array", "items": {{"type": "string"}}}}}}, "required": ["foo"]}}}}
+would match an object with one required property, "foo". The "type" property specifies "foo" must be an "array", and the "description" property semantically describes it as "a list of test words". The items within "foo" must be strings.
+Thus, the object {{"foo": ["bar", "baz"]}} is a well-formatted instance of this example "JSON Schema". The object {{"properties": {{"foo": ["bar", "baz"]}}}} is not well-formatted.
+
+Here are the JSON Schema instances for the tools you have access to:
+
+{tool_schemas}
+
+The way you use the tools is as follows:
+
+------------------------
+
+${AGENT_ACTION_FORMAT_INSTRUCTIONS}
+
+If you are using a tool, "action_input" must adhere to the tool's input schema, given above.
+
+------------------------
+
+ALWAYS use the following format:
+
+Question: the input question you must answer
+Thought: you should always think about what to do
+Action:
+\`\`\`json
+$JSON_BLOB
+\`\`\`
+Observation: the result of the action
+... (this Thought/Action/Observation can repeat N times)
+Thought: I now know the final answer
+Action:
+\`\`\`json
+{{
+  "action": "Final Answer",
+  "action_input": "Final response to human"
+}}
+\`\`\``;
+const SUFFIX = `Begin! Reminder to ALWAYS use the above format, and to use tools if appropriate.`;
+
+//#endregion
+exports.AGENT_ACTION_FORMAT_INSTRUCTIONS = AGENT_ACTION_FORMAT_INSTRUCTIONS;
+exports.FORMAT_INSTRUCTIONS = FORMAT_INSTRUCTIONS;
+exports.PREFIX = PREFIX;
+exports.SUFFIX = SUFFIX;
+//# sourceMappingURL=prompt.cjs.map

package/dist/agents/structured_chat/prompt.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.cjs","names":[],"sources":["../../../src/agents/structured_chat/prompt.ts"],"sourcesContent":["export const PREFIX = `Answer the following questions truthfully and as best you can.`;\nexport const AGENT_ACTION_FORMAT_INSTRUCTIONS = `Output a JSON markdown code snippet containing a valid JSON blob (denoted below by $JSON_BLOB).\nThis $JSON_BLOB must have a \"action\" key (with the name of the tool to use) and an \"action_input\" key (tool input).\n\nValid \"action\" values: \"Final Answer\" (which you must use when giving your final response to the user), or one of [{tool_names}].\n\nThe $JSON_BLOB must be valid, parseable JSON and only contain a SINGLE action. Here is an example of an acceptable output:\n\n\\`\\`\\`json\n{{\n  \"action\": $TOOL_NAME,\n  \"action_input\": $INPUT\n}}\n\\`\\`\\`\n\nRemember to include the surrounding markdown code snippet delimiters (begin with \"\\`\\`\\`\" json and close with \"\\`\\`\\`\")!\n`;\nexport const FORMAT_INSTRUCTIONS = `You have access to the following tools.\nYou must format your inputs to these tools to match their \"JSON schema\" definitions below.\n\n\"JSON Schema\" is a declarative language that allows you to annotate and validate JSON documents.\n\nFor example, the example \"JSON Schema\" instance {{\"properties\": {{\"foo\": {{\"description\": \"a list of test words\", \"type\": \"array\", \"items\": {{\"type\": \"string\"}}}}}}, \"required\": [\"foo\"]}}}}\nwould match an object with one required property, \"foo\". The \"type\" property specifies \"foo\" must be an \"array\", and the \"description\" property semantically describes it as \"a list of test words\". The items within \"foo\" must be strings.\nThus, the object {{\"foo\": [\"bar\", \"baz\"]}} is a well-formatted instance of this example \"JSON Schema\". The object {{\"properties\": {{\"foo\": [\"bar\", \"baz\"]}}}} is not well-formatted.\n\nHere are the JSON Schema instances for the tools you have access to:\n\n{tool_schemas}\n\nThe way you use the tools is as follows:\n\n------------------------\n\n${AGENT_ACTION_FORMAT_INSTRUCTIONS}\n\nIf you are using a tool, \"action_input\" must adhere to the tool's input schema, given above.\n\n------------------------\n\nALWAYS use the following format:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction:\n\\`\\`\\`json\n$JSON_BLOB\n\\`\\`\\`\nObservation: the result of the action\n... (this Thought/Action/Observation can repeat N times)\nThought: I now know the final answer\nAction:\n\\`\\`\\`json\n{{\n  \"action\": \"Final Answer\",\n  \"action_input\": \"Final response to human\"\n}}\n\\`\\`\\``;\nexport const SUFFIX = `Begin! Reminder to ALWAYS use the above format, and to use tools if appropriate.`;\n"],"mappings":";;AAAA,MAAa,SAAS,CAAC,8DAA8D,CAAC;AACtF,MAAa,mCAAmC,CAAC;;;;;;;;;;;;;;;AAejD,CAAC;AACD,MAAa,sBAAsB,CAAC;;;;;;;;;;;;;;;;;AAiBpC,EAAE,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;MAuB7B,CAAC;AACP,MAAa,SAAS,CAAC,gFAAgF,CAAC"}