@langchain/classic 1.0.0-alpha.1

package/dist/agents/toolkits/openapi/openapi.cjs

@@ -0,0 +1,107 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_llm_chain = require('../../../chains/llm_chain.cjs');
+const require_index = require('../../mrkl/index.cjs');
+const require_executor = require('../../executor.cjs');
+const require_json = require('../json/json.cjs');
+const require_prompt = require('./prompt.cjs');
+const require_requests = require('../../../tools/requests.cjs');
+const __langchain_core_tools = require_rolldown_runtime.__toESM(require("@langchain/core/tools"));
+
+//#region src/agents/toolkits/openapi/openapi.ts
+/**
+* Represents a toolkit for making HTTP requests. It initializes the
+* request tools based on the provided headers.
+*/
+var RequestsToolkit = class extends __langchain_core_tools.BaseToolkit {
+	tools;
+	constructor(headers) {
+		super();
+		this.tools = [new require_requests.RequestsGetTool(headers), new require_requests.RequestsPostTool(headers)];
+	}
+};
+/**
+* Extends the `RequestsToolkit` class and adds a dynamic tool for
+* exploring JSON data. It creates a JSON agent using the `JsonToolkit`
+* and the provided language model, and adds the JSON explorer tool to the
+* toolkit.
+* @example
+* ```typescript
+* const toolkit = new OpenApiToolkit(
+*   new JsonSpec({
+*   }),
+*   new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0 }),
+*   {
+*     "Content-Type": "application/json",
+*     Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
+*   },
+* );
+*
+* const result = await toolkit.invoke({
+*   input:
+*     "Make a POST request to openai /completions. The prompt should be 'tell me a joke.'",
+* });
+* console.log(`Got output ${result.output}`);
+* ```
+*/
+var OpenApiToolkit = class extends RequestsToolkit {
+	constructor(jsonSpec, llm, headers) {
+		super(headers);
+		const jsonAgent = require_json.createJsonAgent(llm, new require_json.JsonToolkit(jsonSpec));
+		this.tools = [...this.tools, new __langchain_core_tools.DynamicTool({
+			name: "json_explorer",
+			func: async (input) => {
+				const result = await jsonAgent.call({ input });
+				return result.output;
+			},
+			description: require_prompt.JSON_EXPLORER_DESCRIPTION
+		})];
+	}
+};
+/**
+* Creates an OpenAPI agent using a language model, an OpenAPI toolkit,
+* and optional prompt arguments. It creates a prompt for the agent using
+* the OpenAPI tools and the provided prefix and suffix. It then creates a
+* ZeroShotAgent with the prompt and the OpenAPI tools, and returns an
+* AgentExecutor for executing the agent with the tools.
+* @param llm The language model to use.
+* @param openApiToolkit The OpenAPI toolkit to use.
+* @param args Optional arguments for creating the prompt.
+* @returns An AgentExecutor for executing the agent with the tools.
+*
+* @security **Security Notice** This agent provides access to external APIs.
+* Use with caution as this agent can make API calls with arbitrary headers.
+* Exposing this agent to users could lead to security vulnerabilities. Consider
+* limiting access to what endpoints it can hit, what actions can be taken, and
+* more.
+*
+* @link See https://js.langchain.com/docs/security for more information.
+*/
+function createOpenApiAgent(llm, openApiToolkit, args) {
+	const { prefix = require_prompt.OPENAPI_PREFIX, suffix = require_prompt.OPENAPI_SUFFIX, inputVariables = ["input", "agent_scratchpad"] } = args ?? {};
+	const { tools } = openApiToolkit;
+	const prompt = require_index.ZeroShotAgent.createPrompt(tools, {
+		prefix,
+		suffix,
+		inputVariables
+	});
+	const chain = new require_llm_chain.LLMChain({
+		prompt,
+		llm
+	});
+	const toolNames = tools.map((tool) => tool.name);
+	const agent = new require_index.ZeroShotAgent({
+		llmChain: chain,
+		allowedTools: toolNames
+	});
+	return require_executor.AgentExecutor.fromAgentAndTools({
+		agent,
+		tools,
+		returnIntermediateSteps: true
+	});
+}
+
+//#endregion
+exports.OpenApiToolkit = OpenApiToolkit;
+exports.RequestsToolkit = RequestsToolkit;
+exports.createOpenApiAgent = createOpenApiAgent;
+//# sourceMappingURL=openapi.cjs.map

package/dist/agents/toolkits/openapi/openapi.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.cjs","names":["BaseToolkit","headers?: Headers","RequestsGetTool","RequestsPostTool","jsonSpec: JsonSpec","llm: BaseLanguageModelInterface","createJsonAgent","JsonToolkit","DynamicTool","input: string","JSON_EXPLORER_DESCRIPTION","openApiToolkit: OpenApiToolkit","args?: ZeroShotCreatePromptArgs","OPENAPI_PREFIX","OPENAPI_SUFFIX","ZeroShotAgent","LLMChain","AgentExecutor"],"sources":["../../../../src/agents/toolkits/openapi/openapi.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { ToolInterface } from \"@langchain/core/tools\";\nimport { DynamicTool, BaseToolkit } from \"@langchain/core/tools\";\nimport { JsonSpec } from \"../../../tools/json.js\";\nimport { AgentExecutor } from \"../../executor.js\";\nimport {\n  OPENAPI_PREFIX,\n  OPENAPI_SUFFIX,\n  JSON_EXPLORER_DESCRIPTION,\n} from \"./prompt.js\";\nimport { LLMChain } from \"../../../chains/llm_chain.js\";\nimport { ZeroShotCreatePromptArgs, ZeroShotAgent } from \"../../mrkl/index.js\";\nimport {\n  Headers,\n  RequestsGetTool,\n  RequestsPostTool,\n} from \"../../../tools/requests.js\";\nimport { createJsonAgent, JsonToolkit } from \"../json/json.js\";\n\n/**\n * Represents a toolkit for making HTTP requests. It initializes the\n * request tools based on the provided headers.\n */\nexport class RequestsToolkit extends BaseToolkit {\n  tools: ToolInterface[];\n\n  constructor(headers?: Headers) {\n    super();\n    this.tools = [new RequestsGetTool(headers), new RequestsPostTool(headers)];\n  }\n}\n\n/**\n * Extends the `RequestsToolkit` class and adds a dynamic tool for\n * exploring JSON data. It creates a JSON agent using the `JsonToolkit`\n * and the provided language model, and adds the JSON explorer tool to the\n * toolkit.\n * @example\n * ```typescript\n * const toolkit = new OpenApiToolkit(\n *   new JsonSpec({\n *   }),\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     \"Content-Type\": \"application/json\",\n *     Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,\n *   },\n * );\n *\n * const result = await toolkit.invoke({\n *   input:\n *     \"Make a POST request to openai /completions. The prompt should be 'tell me a joke.'\",\n * });\n * console.log(`Got output ${result.output}`);\n * ```\n */\nexport class OpenApiToolkit extends RequestsToolkit {\n  constructor(\n    jsonSpec: JsonSpec,\n    llm: BaseLanguageModelInterface,\n    headers?: Headers\n  ) {\n    super(headers);\n    const jsonAgent = createJsonAgent(llm, new JsonToolkit(jsonSpec));\n    this.tools = [\n      ...this.tools,\n      new DynamicTool({\n        name: \"json_explorer\",\n        func: async (input: string) => {\n          const result = await jsonAgent.call({ input });\n          return result.output as string;\n        },\n        description: JSON_EXPLORER_DESCRIPTION,\n      }),\n    ];\n  }\n}\n\n/**\n * Creates an OpenAPI agent using a language model, an OpenAPI toolkit,\n * and optional prompt arguments. It creates a prompt for the agent using\n * the OpenAPI tools and the provided prefix and suffix. It then creates a\n * ZeroShotAgent with the prompt and the OpenAPI tools, and returns an\n * AgentExecutor for executing the agent with the tools.\n * @param llm The language model to use.\n * @param openApiToolkit The OpenAPI toolkit to use.\n * @param args Optional arguments for creating the prompt.\n * @returns An AgentExecutor for executing the agent with the tools.\n *\n * @security **Security Notice** This agent provides access to external APIs.\n * Use with caution as this agent can make API calls with arbitrary headers.\n * Exposing this agent to users could lead to security vulnerabilities. Consider\n * limiting access to what endpoints it can hit, what actions can be taken, and\n * more.\n *\n * @link See https://js.langchain.com/docs/security for more information.\n */\nexport function createOpenApiAgent(\n  llm: BaseLanguageModelInterface,\n  openApiToolkit: OpenApiToolkit,\n  args?: ZeroShotCreatePromptArgs\n) {\n  const {\n    prefix = OPENAPI_PREFIX,\n    suffix = OPENAPI_SUFFIX,\n    inputVariables = [\"input\", \"agent_scratchpad\"],\n  } = args ?? {};\n\n  const { tools } = openApiToolkit;\n  const prompt = ZeroShotAgent.createPrompt(tools, {\n    prefix,\n    suffix,\n    inputVariables,\n  });\n  const chain = new LLMChain({\n    prompt,\n    llm,\n  });\n  const toolNames = tools.map((tool) => tool.name);\n  const agent = new ZeroShotAgent({ llmChain: chain, allowedTools: toolNames });\n  return AgentExecutor.fromAgentAndTools({\n    agent,\n    tools,\n    returnIntermediateSteps: true,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AAuBA,IAAa,kBAAb,cAAqCA,mCAAY;CAC/C;CAEA,YAAYC,SAAmB;EAC7B,OAAO;EACP,KAAK,QAAQ,CAAC,IAAIC,iCAAgB,UAAU,IAAIC,kCAAiB,QAAS;CAC3E;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA0BD,IAAa,iBAAb,cAAoC,gBAAgB;CAClD,YACEC,UACAC,KACAJ,SACA;EACA,MAAM,QAAQ;EACd,MAAM,YAAYK,6BAAgB,KAAK,IAAIC,yBAAY,UAAU;EACjE,KAAK,QAAQ,CACX,GAAG,KAAK,OACR,IAAIC,mCAAY;GACd,MAAM;GACN,MAAM,OAAOC,UAAkB;IAC7B,MAAM,SAAS,MAAM,UAAU,KAAK,EAAE,MAAO,EAAC;AAC9C,WAAO,OAAO;GACf;GACD,aAAaC;EACd,EACF;CACF;AACF;;;;;;;;;;;;;;;;;;;;AAqBD,SAAgB,mBACdL,KACAM,gBACAC,MACA;CACA,MAAM,EACJ,SAASC,+BACT,SAASC,+BACT,iBAAiB,CAAC,SAAS,kBAAmB,GAC/C,GAAG,QAAQ,CAAE;CAEd,MAAM,EAAE,OAAO,GAAG;CAClB,MAAM,SAASC,4BAAc,aAAa,OAAO;EAC/C;EACA;EACA;CACD,EAAC;CACF,MAAM,QAAQ,IAAIC,2BAAS;EACzB;EACA;CACD;CACD,MAAM,YAAY,MAAM,IAAI,CAAC,SAAS,KAAK,KAAK;CAChD,MAAM,QAAQ,IAAID,4BAAc;EAAE,UAAU;EAAO,cAAc;CAAW;AAC5E,QAAOE,+BAAc,kBAAkB;EACrC;EACA;EACA,yBAAyB;CAC1B,EAAC;AACH"}

package/dist/agents/toolkits/openapi/openapi.d.cts

@@ -0,0 +1,67 @@
+import { JsonSpec } from "../../../tools/json.cjs";
+import { ZeroShotCreatePromptArgs } from "../../mrkl/index.cjs";
+import { AgentExecutor } from "../../executor.cjs";
+import { Headers } from "../../../tools/requests.cjs";
+import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import { BaseToolkit, ToolInterface } from "@langchain/core/tools";
+
+//#region src/agents/toolkits/openapi/openapi.d.ts
+
+/**
+ * Represents a toolkit for making HTTP requests. It initializes the
+ * request tools based on the provided headers.
+ */
+declare class RequestsToolkit extends BaseToolkit {
+  tools: ToolInterface[];
+  constructor(headers?: Headers);
+}
+/**
+ * Extends the `RequestsToolkit` class and adds a dynamic tool for
+ * exploring JSON data. It creates a JSON agent using the `JsonToolkit`
+ * and the provided language model, and adds the JSON explorer tool to the
+ * toolkit.
+ * @example
+ * ```typescript
+ * const toolkit = new OpenApiToolkit(
+ *   new JsonSpec({
+ *   }),
+ *   new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0 }),
+ *   {
+ *     "Content-Type": "application/json",
+ *     Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
+ *   },
+ * );
+ *
+ * const result = await toolkit.invoke({
+ *   input:
+ *     "Make a POST request to openai /completions. The prompt should be 'tell me a joke.'",
+ * });
+ * console.log(`Got output ${result.output}`);
+ * ```
+ */
+declare class OpenApiToolkit extends RequestsToolkit {
+  constructor(jsonSpec: JsonSpec, llm: BaseLanguageModelInterface, headers?: Headers);
+}
+/**
+ * Creates an OpenAPI agent using a language model, an OpenAPI toolkit,
+ * and optional prompt arguments. It creates a prompt for the agent using
+ * the OpenAPI tools and the provided prefix and suffix. It then creates a
+ * ZeroShotAgent with the prompt and the OpenAPI tools, and returns an
+ * AgentExecutor for executing the agent with the tools.
+ * @param llm The language model to use.
+ * @param openApiToolkit The OpenAPI toolkit to use.
+ * @param args Optional arguments for creating the prompt.
+ * @returns An AgentExecutor for executing the agent with the tools.
+ *
+ * @security **Security Notice** This agent provides access to external APIs.
+ * Use with caution as this agent can make API calls with arbitrary headers.
+ * Exposing this agent to users could lead to security vulnerabilities. Consider
+ * limiting access to what endpoints it can hit, what actions can be taken, and
+ * more.
+ *
+ * @link See https://js.langchain.com/docs/security for more information.
+ */
+declare function createOpenApiAgent(llm: BaseLanguageModelInterface, openApiToolkit: OpenApiToolkit, args?: ZeroShotCreatePromptArgs): AgentExecutor;
+//#endregion
+export { OpenApiToolkit, RequestsToolkit, createOpenApiAgent };
+//# sourceMappingURL=openapi.d.cts.map

package/dist/agents/toolkits/openapi/openapi.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.d.cts","names":["BaseLanguageModelInterface","ToolInterface","BaseToolkit","JsonSpec","AgentExecutor","ZeroShotCreatePromptArgs","Headers","RequestsToolkit","OpenApiToolkit","createOpenApiAgent"],"sources":["../../../../src/agents/toolkits/openapi/openapi.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { ToolInterface } from \"@langchain/core/tools\";\nimport { BaseToolkit } from \"@langchain/core/tools\";\nimport { JsonSpec } from \"../../../tools/json.js\";\nimport { AgentExecutor } from \"../../executor.js\";\nimport { ZeroShotCreatePromptArgs } from \"../../mrkl/index.js\";\nimport { Headers } from \"../../../tools/requests.js\";\n/**\n * Represents a toolkit for making HTTP requests. It initializes the\n * request tools based on the provided headers.\n */\nexport declare class RequestsToolkit extends BaseToolkit {\n    tools: ToolInterface[];\n    constructor(headers?: Headers);\n}\n/**\n * Extends the `RequestsToolkit` class and adds a dynamic tool for\n * exploring JSON data. It creates a JSON agent using the `JsonToolkit`\n * and the provided language model, and adds the JSON explorer tool to the\n * toolkit.\n * @example\n * ```typescript\n * const toolkit = new OpenApiToolkit(\n *   new JsonSpec({\n *   }),\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     \"Content-Type\": \"application/json\",\n *     Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,\n *   },\n * );\n *\n * const result = await toolkit.invoke({\n *   input:\n *     \"Make a POST request to openai /completions. The prompt should be 'tell me a joke.'\",\n * });\n * console.log(`Got output ${result.output}`);\n * ```\n */\nexport declare class OpenApiToolkit extends RequestsToolkit {\n    constructor(jsonSpec: JsonSpec, llm: BaseLanguageModelInterface, headers?: Headers);\n}\n/**\n * Creates an OpenAPI agent using a language model, an OpenAPI toolkit,\n * and optional prompt arguments. It creates a prompt for the agent using\n * the OpenAPI tools and the provided prefix and suffix. It then creates a\n * ZeroShotAgent with the prompt and the OpenAPI tools, and returns an\n * AgentExecutor for executing the agent with the tools.\n * @param llm The language model to use.\n * @param openApiToolkit The OpenAPI toolkit to use.\n * @param args Optional arguments for creating the prompt.\n * @returns An AgentExecutor for executing the agent with the tools.\n *\n * @security **Security Notice** This agent provides access to external APIs.\n * Use with caution as this agent can make API calls with arbitrary headers.\n * Exposing this agent to users could lead to security vulnerabilities. Consider\n * limiting access to what endpoints it can hit, what actions can be taken, and\n * more.\n *\n * @link See https://js.langchain.com/docs/security for more information.\n */\nexport declare function createOpenApiAgent(llm: BaseLanguageModelInterface, openApiToolkit: OpenApiToolkit, args?: ZeroShotCreatePromptArgs): AgentExecutor;\n"],"mappings":";;;;;;;;;;AAWA;;;AAE0BM,cAFLC,eAAAA,SAAwBL,WAAAA,CAEnBI;EAAO,KAFYJ,EAClCD,aADkCC,EAAAA;EAAW,WAAA,CAAA,OAAA,CAAA,EAE9BI,OAF8B;AA4BxD;;;;;;AAA2D;AAsB3D;;;;;;AAA2J;;;;;;;;;;;;cAtBtIE,cAAAA,SAAuBD,eAAAA;wBAClBJ,eAAeH,sCAAsCM;;;;;;;;;;;;;;;;;;;;;iBAqBvDG,kBAAAA,MAAwBT,4CAA4CQ,uBAAuBH,2BAA2BD"}

package/dist/agents/toolkits/openapi/openapi.d.ts

@@ -0,0 +1,67 @@
+import { JsonSpec } from "../../../tools/json.js";
+import { ZeroShotCreatePromptArgs } from "../../mrkl/index.js";
+import { AgentExecutor } from "../../executor.js";
+import { Headers } from "../../../tools/requests.js";
+import { BaseToolkit, ToolInterface } from "@langchain/core/tools";
+import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+
+//#region src/agents/toolkits/openapi/openapi.d.ts
+
+/**
+ * Represents a toolkit for making HTTP requests. It initializes the
+ * request tools based on the provided headers.
+ */
+declare class RequestsToolkit extends BaseToolkit {
+  tools: ToolInterface[];
+  constructor(headers?: Headers);
+}
+/**
+ * Extends the `RequestsToolkit` class and adds a dynamic tool for
+ * exploring JSON data. It creates a JSON agent using the `JsonToolkit`
+ * and the provided language model, and adds the JSON explorer tool to the
+ * toolkit.
+ * @example
+ * ```typescript
+ * const toolkit = new OpenApiToolkit(
+ *   new JsonSpec({
+ *   }),
+ *   new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0 }),
+ *   {
+ *     "Content-Type": "application/json",
+ *     Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
+ *   },
+ * );
+ *
+ * const result = await toolkit.invoke({
+ *   input:
+ *     "Make a POST request to openai /completions. The prompt should be 'tell me a joke.'",
+ * });
+ * console.log(`Got output ${result.output}`);
+ * ```
+ */
+declare class OpenApiToolkit extends RequestsToolkit {
+  constructor(jsonSpec: JsonSpec, llm: BaseLanguageModelInterface, headers?: Headers);
+}
+/**
+ * Creates an OpenAPI agent using a language model, an OpenAPI toolkit,
+ * and optional prompt arguments. It creates a prompt for the agent using
+ * the OpenAPI tools and the provided prefix and suffix. It then creates a
+ * ZeroShotAgent with the prompt and the OpenAPI tools, and returns an
+ * AgentExecutor for executing the agent with the tools.
+ * @param llm The language model to use.
+ * @param openApiToolkit The OpenAPI toolkit to use.
+ * @param args Optional arguments for creating the prompt.
+ * @returns An AgentExecutor for executing the agent with the tools.
+ *
+ * @security **Security Notice** This agent provides access to external APIs.
+ * Use with caution as this agent can make API calls with arbitrary headers.
+ * Exposing this agent to users could lead to security vulnerabilities. Consider
+ * limiting access to what endpoints it can hit, what actions can be taken, and
+ * more.
+ *
+ * @link See https://js.langchain.com/docs/security for more information.
+ */
+declare function createOpenApiAgent(llm: BaseLanguageModelInterface, openApiToolkit: OpenApiToolkit, args?: ZeroShotCreatePromptArgs): AgentExecutor;
+//#endregion
+export { OpenApiToolkit, RequestsToolkit, createOpenApiAgent };
+//# sourceMappingURL=openapi.d.ts.map

package/dist/agents/toolkits/openapi/openapi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.d.ts","names":["BaseLanguageModelInterface","ToolInterface","BaseToolkit","JsonSpec","AgentExecutor","ZeroShotCreatePromptArgs","Headers","RequestsToolkit","OpenApiToolkit","createOpenApiAgent"],"sources":["../../../../src/agents/toolkits/openapi/openapi.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { ToolInterface } from \"@langchain/core/tools\";\nimport { BaseToolkit } from \"@langchain/core/tools\";\nimport { JsonSpec } from \"../../../tools/json.js\";\nimport { AgentExecutor } from \"../../executor.js\";\nimport { ZeroShotCreatePromptArgs } from \"../../mrkl/index.js\";\nimport { Headers } from \"../../../tools/requests.js\";\n/**\n * Represents a toolkit for making HTTP requests. It initializes the\n * request tools based on the provided headers.\n */\nexport declare class RequestsToolkit extends BaseToolkit {\n    tools: ToolInterface[];\n    constructor(headers?: Headers);\n}\n/**\n * Extends the `RequestsToolkit` class and adds a dynamic tool for\n * exploring JSON data. It creates a JSON agent using the `JsonToolkit`\n * and the provided language model, and adds the JSON explorer tool to the\n * toolkit.\n * @example\n * ```typescript\n * const toolkit = new OpenApiToolkit(\n *   new JsonSpec({\n *   }),\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     \"Content-Type\": \"application/json\",\n *     Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,\n *   },\n * );\n *\n * const result = await toolkit.invoke({\n *   input:\n *     \"Make a POST request to openai /completions. The prompt should be 'tell me a joke.'\",\n * });\n * console.log(`Got output ${result.output}`);\n * ```\n */\nexport declare class OpenApiToolkit extends RequestsToolkit {\n    constructor(jsonSpec: JsonSpec, llm: BaseLanguageModelInterface, headers?: Headers);\n}\n/**\n * Creates an OpenAPI agent using a language model, an OpenAPI toolkit,\n * and optional prompt arguments. It creates a prompt for the agent using\n * the OpenAPI tools and the provided prefix and suffix. It then creates a\n * ZeroShotAgent with the prompt and the OpenAPI tools, and returns an\n * AgentExecutor for executing the agent with the tools.\n * @param llm The language model to use.\n * @param openApiToolkit The OpenAPI toolkit to use.\n * @param args Optional arguments for creating the prompt.\n * @returns An AgentExecutor for executing the agent with the tools.\n *\n * @security **Security Notice** This agent provides access to external APIs.\n * Use with caution as this agent can make API calls with arbitrary headers.\n * Exposing this agent to users could lead to security vulnerabilities. Consider\n * limiting access to what endpoints it can hit, what actions can be taken, and\n * more.\n *\n * @link See https://js.langchain.com/docs/security for more information.\n */\nexport declare function createOpenApiAgent(llm: BaseLanguageModelInterface, openApiToolkit: OpenApiToolkit, args?: ZeroShotCreatePromptArgs): AgentExecutor;\n"],"mappings":";;;;;;;;;;AAWA;;;AAE0BM,cAFLC,eAAAA,SAAwBL,WAAAA,CAEnBI;EAAO,KAFYJ,EAClCD,aADkCC,EAAAA;EAAW,WAAA,CAAA,OAAA,CAAA,EAE9BI,OAF8B;AA4BxD;;;;;;AAA2D;AAsB3D;;;;;;AAA2J;;;;;;;;;;;;cAtBtIE,cAAAA,SAAuBD,eAAAA;wBAClBJ,eAAeH,sCAAsCM;;;;;;;;;;;;;;;;;;;;;iBAqBvDG,kBAAAA,MAAwBT,4CAA4CQ,uBAAuBH,2BAA2BD"}

package/dist/agents/toolkits/openapi/openapi.js

@@ -0,0 +1,104 @@
+import { LLMChain } from "../../../chains/llm_chain.js";
+import { ZeroShotAgent } from "../../mrkl/index.js";
+import { AgentExecutor } from "../../executor.js";
+import { JsonToolkit, createJsonAgent } from "../json/json.js";
+import { JSON_EXPLORER_DESCRIPTION, OPENAPI_PREFIX, OPENAPI_SUFFIX } from "./prompt.js";
+import { RequestsGetTool, RequestsPostTool } from "../../../tools/requests.js";
+import { BaseToolkit, DynamicTool } from "@langchain/core/tools";
+
+//#region src/agents/toolkits/openapi/openapi.ts
+/**
+* Represents a toolkit for making HTTP requests. It initializes the
+* request tools based on the provided headers.
+*/
+var RequestsToolkit = class extends BaseToolkit {
+	tools;
+	constructor(headers) {
+		super();
+		this.tools = [new RequestsGetTool(headers), new RequestsPostTool(headers)];
+	}
+};
+/**
+* Extends the `RequestsToolkit` class and adds a dynamic tool for
+* exploring JSON data. It creates a JSON agent using the `JsonToolkit`
+* and the provided language model, and adds the JSON explorer tool to the
+* toolkit.
+* @example
+* ```typescript
+* const toolkit = new OpenApiToolkit(
+*   new JsonSpec({
+*   }),
+*   new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0 }),
+*   {
+*     "Content-Type": "application/json",
+*     Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
+*   },
+* );
+*
+* const result = await toolkit.invoke({
+*   input:
+*     "Make a POST request to openai /completions. The prompt should be 'tell me a joke.'",
+* });
+* console.log(`Got output ${result.output}`);
+* ```
+*/
+var OpenApiToolkit = class extends RequestsToolkit {
+	constructor(jsonSpec, llm, headers) {
+		super(headers);
+		const jsonAgent = createJsonAgent(llm, new JsonToolkit(jsonSpec));
+		this.tools = [...this.tools, new DynamicTool({
+			name: "json_explorer",
+			func: async (input) => {
+				const result = await jsonAgent.call({ input });
+				return result.output;
+			},
+			description: JSON_EXPLORER_DESCRIPTION
+		})];
+	}
+};
+/**
+* Creates an OpenAPI agent using a language model, an OpenAPI toolkit,
+* and optional prompt arguments. It creates a prompt for the agent using
+* the OpenAPI tools and the provided prefix and suffix. It then creates a
+* ZeroShotAgent with the prompt and the OpenAPI tools, and returns an
+* AgentExecutor for executing the agent with the tools.
+* @param llm The language model to use.
+* @param openApiToolkit The OpenAPI toolkit to use.
+* @param args Optional arguments for creating the prompt.
+* @returns An AgentExecutor for executing the agent with the tools.
+*
+* @security **Security Notice** This agent provides access to external APIs.
+* Use with caution as this agent can make API calls with arbitrary headers.
+* Exposing this agent to users could lead to security vulnerabilities. Consider
+* limiting access to what endpoints it can hit, what actions can be taken, and
+* more.
+*
+* @link See https://js.langchain.com/docs/security for more information.
+*/
+function createOpenApiAgent(llm, openApiToolkit, args) {
+	const { prefix = OPENAPI_PREFIX, suffix = OPENAPI_SUFFIX, inputVariables = ["input", "agent_scratchpad"] } = args ?? {};
+	const { tools } = openApiToolkit;
+	const prompt = ZeroShotAgent.createPrompt(tools, {
+		prefix,
+		suffix,
+		inputVariables
+	});
+	const chain = new LLMChain({
+		prompt,
+		llm
+	});
+	const toolNames = tools.map((tool) => tool.name);
+	const agent = new ZeroShotAgent({
+		llmChain: chain,
+		allowedTools: toolNames
+	});
+	return AgentExecutor.fromAgentAndTools({
+		agent,
+		tools,
+		returnIntermediateSteps: true
+	});
+}
+
+//#endregion
+export { OpenApiToolkit, RequestsToolkit, createOpenApiAgent };
+//# sourceMappingURL=openapi.js.map

package/dist/agents/toolkits/openapi/openapi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.js","names":["headers?: Headers","jsonSpec: JsonSpec","llm: BaseLanguageModelInterface","input: string","openApiToolkit: OpenApiToolkit","args?: ZeroShotCreatePromptArgs"],"sources":["../../../../src/agents/toolkits/openapi/openapi.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { ToolInterface } from \"@langchain/core/tools\";\nimport { DynamicTool, BaseToolkit } from \"@langchain/core/tools\";\nimport { JsonSpec } from \"../../../tools/json.js\";\nimport { AgentExecutor } from \"../../executor.js\";\nimport {\n  OPENAPI_PREFIX,\n  OPENAPI_SUFFIX,\n  JSON_EXPLORER_DESCRIPTION,\n} from \"./prompt.js\";\nimport { LLMChain } from \"../../../chains/llm_chain.js\";\nimport { ZeroShotCreatePromptArgs, ZeroShotAgent } from \"../../mrkl/index.js\";\nimport {\n  Headers,\n  RequestsGetTool,\n  RequestsPostTool,\n} from \"../../../tools/requests.js\";\nimport { createJsonAgent, JsonToolkit } from \"../json/json.js\";\n\n/**\n * Represents a toolkit for making HTTP requests. It initializes the\n * request tools based on the provided headers.\n */\nexport class RequestsToolkit extends BaseToolkit {\n  tools: ToolInterface[];\n\n  constructor(headers?: Headers) {\n    super();\n    this.tools = [new RequestsGetTool(headers), new RequestsPostTool(headers)];\n  }\n}\n\n/**\n * Extends the `RequestsToolkit` class and adds a dynamic tool for\n * exploring JSON data. It creates a JSON agent using the `JsonToolkit`\n * and the provided language model, and adds the JSON explorer tool to the\n * toolkit.\n * @example\n * ```typescript\n * const toolkit = new OpenApiToolkit(\n *   new JsonSpec({\n *   }),\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     \"Content-Type\": \"application/json\",\n *     Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,\n *   },\n * );\n *\n * const result = await toolkit.invoke({\n *   input:\n *     \"Make a POST request to openai /completions. The prompt should be 'tell me a joke.'\",\n * });\n * console.log(`Got output ${result.output}`);\n * ```\n */\nexport class OpenApiToolkit extends RequestsToolkit {\n  constructor(\n    jsonSpec: JsonSpec,\n    llm: BaseLanguageModelInterface,\n    headers?: Headers\n  ) {\n    super(headers);\n    const jsonAgent = createJsonAgent(llm, new JsonToolkit(jsonSpec));\n    this.tools = [\n      ...this.tools,\n      new DynamicTool({\n        name: \"json_explorer\",\n        func: async (input: string) => {\n          const result = await jsonAgent.call({ input });\n          return result.output as string;\n        },\n        description: JSON_EXPLORER_DESCRIPTION,\n      }),\n    ];\n  }\n}\n\n/**\n * Creates an OpenAPI agent using a language model, an OpenAPI toolkit,\n * and optional prompt arguments. It creates a prompt for the agent using\n * the OpenAPI tools and the provided prefix and suffix. It then creates a\n * ZeroShotAgent with the prompt and the OpenAPI tools, and returns an\n * AgentExecutor for executing the agent with the tools.\n * @param llm The language model to use.\n * @param openApiToolkit The OpenAPI toolkit to use.\n * @param args Optional arguments for creating the prompt.\n * @returns An AgentExecutor for executing the agent with the tools.\n *\n * @security **Security Notice** This agent provides access to external APIs.\n * Use with caution as this agent can make API calls with arbitrary headers.\n * Exposing this agent to users could lead to security vulnerabilities. Consider\n * limiting access to what endpoints it can hit, what actions can be taken, and\n * more.\n *\n * @link See https://js.langchain.com/docs/security for more information.\n */\nexport function createOpenApiAgent(\n  llm: BaseLanguageModelInterface,\n  openApiToolkit: OpenApiToolkit,\n  args?: ZeroShotCreatePromptArgs\n) {\n  const {\n    prefix = OPENAPI_PREFIX,\n    suffix = OPENAPI_SUFFIX,\n    inputVariables = [\"input\", \"agent_scratchpad\"],\n  } = args ?? {};\n\n  const { tools } = openApiToolkit;\n  const prompt = ZeroShotAgent.createPrompt(tools, {\n    prefix,\n    suffix,\n    inputVariables,\n  });\n  const chain = new LLMChain({\n    prompt,\n    llm,\n  });\n  const toolNames = tools.map((tool) => tool.name);\n  const agent = new ZeroShotAgent({ llmChain: chain, allowedTools: toolNames });\n  return AgentExecutor.fromAgentAndTools({\n    agent,\n    tools,\n    returnIntermediateSteps: true,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAuBA,IAAa,kBAAb,cAAqC,YAAY;CAC/C;CAEA,YAAYA,SAAmB;EAC7B,OAAO;EACP,KAAK,QAAQ,CAAC,IAAI,gBAAgB,UAAU,IAAI,iBAAiB,QAAS;CAC3E;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA0BD,IAAa,iBAAb,cAAoC,gBAAgB;CAClD,YACEC,UACAC,KACAF,SACA;EACA,MAAM,QAAQ;EACd,MAAM,YAAY,gBAAgB,KAAK,IAAI,YAAY,UAAU;EACjE,KAAK,QAAQ,CACX,GAAG,KAAK,OACR,IAAI,YAAY;GACd,MAAM;GACN,MAAM,OAAOG,UAAkB;IAC7B,MAAM,SAAS,MAAM,UAAU,KAAK,EAAE,MAAO,EAAC;AAC9C,WAAO,OAAO;GACf;GACD,aAAa;EACd,EACF;CACF;AACF;;;;;;;;;;;;;;;;;;;;AAqBD,SAAgB,mBACdD,KACAE,gBACAC,MACA;CACA,MAAM,EACJ,SAAS,gBACT,SAAS,gBACT,iBAAiB,CAAC,SAAS,kBAAmB,GAC/C,GAAG,QAAQ,CAAE;CAEd,MAAM,EAAE,OAAO,GAAG;CAClB,MAAM,SAAS,cAAc,aAAa,OAAO;EAC/C;EACA;EACA;CACD,EAAC;CACF,MAAM,QAAQ,IAAI,SAAS;EACzB;EACA;CACD;CACD,MAAM,YAAY,MAAM,IAAI,CAAC,SAAS,KAAK,KAAK;CAChD,MAAM,QAAQ,IAAI,cAAc;EAAE,UAAU;EAAO,cAAc;CAAW;AAC5E,QAAO,cAAc,kBAAkB;EACrC;EACA;EACA,yBAAyB;CAC1B,EAAC;AACH"}

package/dist/agents/toolkits/openapi/prompt.cjs

@@ -0,0 +1,37 @@
+
+//#region src/agents/toolkits/openapi/prompt.ts
+const OPENAPI_PREFIX = `You are an agent designed to answer questions by making web requests to an API given the OpenAPI spec.
+
+If the question does not seem related to the API, return I don't know. Do not make up an answer.
+Only use information provided by the tools to construct your response.
+
+To find information in the OpenAPI spec, use the 'json_explorer' tool. The input to this tool is a question about the API.
+
+Take the following steps:
+First, find the base URL needed to make the request.
+
+Second, find the relevant paths needed to answer the question. Take note that, sometimes, you might need to make more than one request to more than one path to answer the question.
+
+Third, find the required parameters needed to make the request. For GET requests, these are usually URL parameters and for POST requests, these are request body parameters.
+
+Fourth, make the requests needed to answer the question. Ensure that you are sending the correct parameters to the request by checking which parameters are required. For parameters with a fixed set of values, please use the spec to look at which values are allowed.
+
+Use the exact parameter names as listed in the spec, do not make up any names or abbreviate the names of parameters.
+If you get a not found error, ensure that you are using a path that actually exists in the spec.`;
+const OPENAPI_SUFFIX = `Begin!"
+
+Question: {input}
+Thought: I should explore the spec to find the base url for the API.
+{agent_scratchpad}`;
+const JSON_EXPLORER_DESCRIPTION = `
+Can be used to answer questions about the openapi spec for the API. Always use this tool before trying to make a request. 
+Example inputs to this tool: 
+    'What are the required query parameters for a GET request to the /bar endpoint?'
+    'What are the required parameters in the request body for a POST request to the /foo endpoint?'
+Always give this tool a specific question.`;
+
+//#endregion
+exports.JSON_EXPLORER_DESCRIPTION = JSON_EXPLORER_DESCRIPTION;
+exports.OPENAPI_PREFIX = OPENAPI_PREFIX;
+exports.OPENAPI_SUFFIX = OPENAPI_SUFFIX;
+//# sourceMappingURL=prompt.cjs.map

package/dist/agents/toolkits/openapi/prompt.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.cjs","names":[],"sources":["../../../../src/agents/toolkits/openapi/prompt.ts"],"sourcesContent":["export const OPENAPI_PREFIX = `You are an agent designed to answer questions by making web requests to an API given the OpenAPI spec.\n\nIf the question does not seem related to the API, return I don't know. Do not make up an answer.\nOnly use information provided by the tools to construct your response.\n\nTo find information in the OpenAPI spec, use the 'json_explorer' tool. The input to this tool is a question about the API.\n\nTake the following steps:\nFirst, find the base URL needed to make the request.\n\nSecond, find the relevant paths needed to answer the question. Take note that, sometimes, you might need to make more than one request to more than one path to answer the question.\n\nThird, find the required parameters needed to make the request. For GET requests, these are usually URL parameters and for POST requests, these are request body parameters.\n\nFourth, make the requests needed to answer the question. Ensure that you are sending the correct parameters to the request by checking which parameters are required. For parameters with a fixed set of values, please use the spec to look at which values are allowed.\n\nUse the exact parameter names as listed in the spec, do not make up any names or abbreviate the names of parameters.\nIf you get a not found error, ensure that you are using a path that actually exists in the spec.`;\n\nexport const OPENAPI_SUFFIX = `Begin!\"\n\nQuestion: {input}\nThought: I should explore the spec to find the base url for the API.\n{agent_scratchpad}`;\nexport const JSON_EXPLORER_DESCRIPTION = `\nCan be used to answer questions about the openapi spec for the API. Always use this tool before trying to make a request. \nExample inputs to this tool: \n    'What are the required query parameters for a GET request to the /bar endpoint?'\n    'What are the required parameters in the request body for a POST request to the /foo endpoint?'\nAlways give this tool a specific question.`;\n"],"mappings":";;AAAA,MAAa,iBAAiB,CAAC;;;;;;;;;;;;;;;;;gGAiBiE,CAAC;AAEjG,MAAa,iBAAiB,CAAC;;;;kBAIb,CAAC;AACnB,MAAa,4BAA4B,CAAC;;;;;0CAKA,CAAC"}

package/dist/agents/toolkits/openapi/prompt.js

@@ -0,0 +1,34 @@
+//#region src/agents/toolkits/openapi/prompt.ts
+const OPENAPI_PREFIX = `You are an agent designed to answer questions by making web requests to an API given the OpenAPI spec.
+
+If the question does not seem related to the API, return I don't know. Do not make up an answer.
+Only use information provided by the tools to construct your response.
+
+To find information in the OpenAPI spec, use the 'json_explorer' tool. The input to this tool is a question about the API.
+
+Take the following steps:
+First, find the base URL needed to make the request.
+
+Second, find the relevant paths needed to answer the question. Take note that, sometimes, you might need to make more than one request to more than one path to answer the question.
+
+Third, find the required parameters needed to make the request. For GET requests, these are usually URL parameters and for POST requests, these are request body parameters.
+
+Fourth, make the requests needed to answer the question. Ensure that you are sending the correct parameters to the request by checking which parameters are required. For parameters with a fixed set of values, please use the spec to look at which values are allowed.
+
+Use the exact parameter names as listed in the spec, do not make up any names or abbreviate the names of parameters.
+If you get a not found error, ensure that you are using a path that actually exists in the spec.`;
+const OPENAPI_SUFFIX = `Begin!"
+
+Question: {input}
+Thought: I should explore the spec to find the base url for the API.
+{agent_scratchpad}`;
+const JSON_EXPLORER_DESCRIPTION = `
+Can be used to answer questions about the openapi spec for the API. Always use this tool before trying to make a request. 
+Example inputs to this tool: 
+    'What are the required query parameters for a GET request to the /bar endpoint?'
+    'What are the required parameters in the request body for a POST request to the /foo endpoint?'
+Always give this tool a specific question.`;
+
+//#endregion
+export { JSON_EXPLORER_DESCRIPTION, OPENAPI_PREFIX, OPENAPI_SUFFIX };
+//# sourceMappingURL=prompt.js.map

package/dist/agents/toolkits/openapi/prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.js","names":[],"sources":["../../../../src/agents/toolkits/openapi/prompt.ts"],"sourcesContent":["export const OPENAPI_PREFIX = `You are an agent designed to answer questions by making web requests to an API given the OpenAPI spec.\n\nIf the question does not seem related to the API, return I don't know. Do not make up an answer.\nOnly use information provided by the tools to construct your response.\n\nTo find information in the OpenAPI spec, use the 'json_explorer' tool. The input to this tool is a question about the API.\n\nTake the following steps:\nFirst, find the base URL needed to make the request.\n\nSecond, find the relevant paths needed to answer the question. Take note that, sometimes, you might need to make more than one request to more than one path to answer the question.\n\nThird, find the required parameters needed to make the request. For GET requests, these are usually URL parameters and for POST requests, these are request body parameters.\n\nFourth, make the requests needed to answer the question. Ensure that you are sending the correct parameters to the request by checking which parameters are required. For parameters with a fixed set of values, please use the spec to look at which values are allowed.\n\nUse the exact parameter names as listed in the spec, do not make up any names or abbreviate the names of parameters.\nIf you get a not found error, ensure that you are using a path that actually exists in the spec.`;\n\nexport const OPENAPI_SUFFIX = `Begin!\"\n\nQuestion: {input}\nThought: I should explore the spec to find the base url for the API.\n{agent_scratchpad}`;\nexport const JSON_EXPLORER_DESCRIPTION = `\nCan be used to answer questions about the openapi spec for the API. Always use this tool before trying to make a request. \nExample inputs to this tool: \n    'What are the required query parameters for a GET request to the /bar endpoint?'\n    'What are the required parameters in the request body for a POST request to the /foo endpoint?'\nAlways give this tool a specific question.`;\n"],"mappings":";AAAA,MAAa,iBAAiB,CAAC;;;;;;;;;;;;;;;;;gGAiBiE,CAAC;AAEjG,MAAa,iBAAiB,CAAC;;;;kBAIb,CAAC;AACnB,MAAa,4BAA4B,CAAC;;;;;0CAKA,CAAC"}

package/dist/agents/toolkits/sql/index.cjs

@@ -0,0 +1,25 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_prompt = require('./prompt.cjs');
+const require_sql = require('./sql.cjs');
+
+//#region src/agents/toolkits/sql/index.ts
+var sql_exports = {};
+require_rolldown_runtime.__export(sql_exports, {
+	SQL_PREFIX: () => require_prompt.SQL_PREFIX,
+	SQL_SUFFIX: () => require_prompt.SQL_SUFFIX,
+	SqlToolkit: () => require_sql.SqlToolkit,
+	createSqlAgent: () => require_sql.createSqlAgent
+});
+
+//#endregion
+exports.SQL_PREFIX = require_prompt.SQL_PREFIX;
+exports.SQL_SUFFIX = require_prompt.SQL_SUFFIX;
+exports.SqlToolkit = require_sql.SqlToolkit;
+exports.createSqlAgent = require_sql.createSqlAgent;
+Object.defineProperty(exports, 'sql_exports', {
+  enumerable: true,
+  get: function () {
+    return sql_exports;
+  }
+});
+//# sourceMappingURL=index.cjs.map

package/dist/agents/toolkits/sql/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../../../../src/agents/toolkits/sql/index.ts"],"sourcesContent":["export { type SqlCreatePromptArgs, SqlToolkit, createSqlAgent } from \"./sql.js\";\nexport { SQL_PREFIX, SQL_SUFFIX } from \"./prompt.js\";\n"],"mappings":""}

package/dist/agents/toolkits/sql/index.d.cts

@@ -0,0 +1,3 @@
+import { SqlCreatePromptArgs, SqlToolkit, createSqlAgent } from "./sql.cjs";
+import { SQL_PREFIX, SQL_SUFFIX } from "./prompt.cjs";
+export { SQL_PREFIX, SQL_SUFFIX, type SqlCreatePromptArgs, SqlToolkit, createSqlAgent };

package/dist/agents/toolkits/sql/index.d.ts

@@ -0,0 +1,3 @@
+import { SqlCreatePromptArgs, SqlToolkit, createSqlAgent } from "./sql.js";
+import { SQL_PREFIX, SQL_SUFFIX } from "./prompt.js";
+export { SQL_PREFIX, SQL_SUFFIX, type SqlCreatePromptArgs, SqlToolkit, createSqlAgent };

package/dist/agents/toolkits/sql/index.js

@@ -0,0 +1,16 @@
+import { __export } from "../../../_virtual/rolldown_runtime.js";
+import { SQL_PREFIX, SQL_SUFFIX } from "./prompt.js";
+import { SqlToolkit, createSqlAgent } from "./sql.js";
+
+//#region src/agents/toolkits/sql/index.ts
+var sql_exports = {};
+__export(sql_exports, {
+	SQL_PREFIX: () => SQL_PREFIX,
+	SQL_SUFFIX: () => SQL_SUFFIX,
+	SqlToolkit: () => SqlToolkit,
+	createSqlAgent: () => createSqlAgent
+});
+
+//#endregion
+export { SQL_PREFIX, SQL_SUFFIX, SqlToolkit, createSqlAgent, sql_exports };
+//# sourceMappingURL=index.js.map

package/dist/agents/toolkits/sql/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/agents/toolkits/sql/index.ts"],"sourcesContent":["export { type SqlCreatePromptArgs, SqlToolkit, createSqlAgent } from \"./sql.js\";\nexport { SQL_PREFIX, SQL_SUFFIX } from \"./prompt.js\";\n"],"mappings":""}

package/dist/agents/toolkits/sql/prompt.cjs

@@ -0,0 +1,24 @@
+
+//#region src/agents/toolkits/sql/prompt.ts
+const SQL_PREFIX = `You are an agent designed to interact with a SQL database.
+Given an input question, create a syntactically correct {dialect} query to run, then look at the results of the query and return the answer.
+Unless the user specifies a specific number of examples they wish to obtain, always limit your query to at most {top_k} results using the LIMIT clause.
+You can order the results by a relevant column to return the most interesting examples in the database.
+Never query for all the columns from a specific table, only ask for a the few relevant columns given the question.
+You have access to tools for interacting with the database.
+Only use the below tools. Only use the information returned by the below tools to construct your final answer.
+You MUST double check your query before executing it. If you get an error while executing a query, rewrite the query and try again.
+
+DO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database.
+
+If the question does not seem related to the database, just return "I don't know" as the answer.`;
+const SQL_SUFFIX = `Begin!
+
+Question: {input}
+Thought: I should look at the tables in the database to see what I can query.
+{agent_scratchpad}`;
+
+//#endregion
+exports.SQL_PREFIX = SQL_PREFIX;
+exports.SQL_SUFFIX = SQL_SUFFIX;
+//# sourceMappingURL=prompt.cjs.map

package/dist/agents/toolkits/sql/prompt.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.cjs","names":[],"sources":["../../../../src/agents/toolkits/sql/prompt.ts"],"sourcesContent":["export const SQL_PREFIX = `You are an agent designed to interact with a SQL database.\nGiven an input question, create a syntactically correct {dialect} query to run, then look at the results of the query and return the answer.\nUnless the user specifies a specific number of examples they wish to obtain, always limit your query to at most {top_k} results using the LIMIT clause.\nYou can order the results by a relevant column to return the most interesting examples in the database.\nNever query for all the columns from a specific table, only ask for a the few relevant columns given the question.\nYou have access to tools for interacting with the database.\nOnly use the below tools. Only use the information returned by the below tools to construct your final answer.\nYou MUST double check your query before executing it. If you get an error while executing a query, rewrite the query and try again.\n\nDO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database.\n\nIf the question does not seem related to the database, just return \"I don't know\" as the answer.`;\n\nexport const SQL_SUFFIX = `Begin!\n\nQuestion: {input}\nThought: I should look at the tables in the database to see what I can query.\n{agent_scratchpad}`;\n"],"mappings":";;AAAA,MAAa,aAAa,CAAC;;;;;;;;;;;gGAWqE,CAAC;AAEjG,MAAa,aAAa,CAAC;;;;kBAIT,CAAC"}

package/dist/agents/toolkits/sql/prompt.d.cts

@@ -0,0 +1,6 @@
+//#region src/agents/toolkits/sql/prompt.d.ts
+declare const SQL_PREFIX = "You are an agent designed to interact with a SQL database.\nGiven an input question, create a syntactically correct {dialect} query to run, then look at the results of the query and return the answer.\nUnless the user specifies a specific number of examples they wish to obtain, always limit your query to at most {top_k} results using the LIMIT clause.\nYou can order the results by a relevant column to return the most interesting examples in the database.\nNever query for all the columns from a specific table, only ask for a the few relevant columns given the question.\nYou have access to tools for interacting with the database.\nOnly use the below tools. Only use the information returned by the below tools to construct your final answer.\nYou MUST double check your query before executing it. If you get an error while executing a query, rewrite the query and try again.\n\nDO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database.\n\nIf the question does not seem related to the database, just return \"I don't know\" as the answer.";
+declare const SQL_SUFFIX = "Begin!\n\nQuestion: {input}\nThought: I should look at the tables in the database to see what I can query.\n{agent_scratchpad}";
+//#endregion
+export { SQL_PREFIX, SQL_SUFFIX };
+//# sourceMappingURL=prompt.d.cts.map

package/dist/agents/toolkits/sql/prompt.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.cts","names":["SQL_PREFIX","SQL_SUFFIX"],"sources":["../../../../src/agents/toolkits/sql/prompt.d.ts"],"sourcesContent":["export declare const SQL_PREFIX = \"You are an agent designed to interact with a SQL database.\\nGiven an input question, create a syntactically correct {dialect} query to run, then look at the results of the query and return the answer.\\nUnless the user specifies a specific number of examples they wish to obtain, always limit your query to at most {top_k} results using the LIMIT clause.\\nYou can order the results by a relevant column to return the most interesting examples in the database.\\nNever query for all the columns from a specific table, only ask for a the few relevant columns given the question.\\nYou have access to tools for interacting with the database.\\nOnly use the below tools. Only use the information returned by the below tools to construct your final answer.\\nYou MUST double check your query before executing it. If you get an error while executing a query, rewrite the query and try again.\\n\\nDO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database.\\n\\nIf the question does not seem related to the database, just return \\\"I don't know\\\" as the answer.\";\nexport declare const SQL_SUFFIX = \"Begin!\\n\\nQuestion: {input}\\nThought: I should look at the tables in the database to see what I can query.\\n{agent_scratchpad}\";\n"],"mappings":";cAAqBA,UAAAA;AAAAA,cACAC,UAAAA,GADU,gIAAA"}

package/dist/agents/toolkits/sql/prompt.d.ts

@@ -0,0 +1,6 @@
+//#region src/agents/toolkits/sql/prompt.d.ts
+declare const SQL_PREFIX = "You are an agent designed to interact with a SQL database.\nGiven an input question, create a syntactically correct {dialect} query to run, then look at the results of the query and return the answer.\nUnless the user specifies a specific number of examples they wish to obtain, always limit your query to at most {top_k} results using the LIMIT clause.\nYou can order the results by a relevant column to return the most interesting examples in the database.\nNever query for all the columns from a specific table, only ask for a the few relevant columns given the question.\nYou have access to tools for interacting with the database.\nOnly use the below tools. Only use the information returned by the below tools to construct your final answer.\nYou MUST double check your query before executing it. If you get an error while executing a query, rewrite the query and try again.\n\nDO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database.\n\nIf the question does not seem related to the database, just return \"I don't know\" as the answer.";
+declare const SQL_SUFFIX = "Begin!\n\nQuestion: {input}\nThought: I should look at the tables in the database to see what I can query.\n{agent_scratchpad}";
+//#endregion
+export { SQL_PREFIX, SQL_SUFFIX };
+//# sourceMappingURL=prompt.d.ts.map

package/dist/agents/toolkits/sql/prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","names":["SQL_PREFIX","SQL_SUFFIX"],"sources":["../../../../src/agents/toolkits/sql/prompt.d.ts"],"sourcesContent":["export declare const SQL_PREFIX = \"You are an agent designed to interact with a SQL database.\\nGiven an input question, create a syntactically correct {dialect} query to run, then look at the results of the query and return the answer.\\nUnless the user specifies a specific number of examples they wish to obtain, always limit your query to at most {top_k} results using the LIMIT clause.\\nYou can order the results by a relevant column to return the most interesting examples in the database.\\nNever query for all the columns from a specific table, only ask for a the few relevant columns given the question.\\nYou have access to tools for interacting with the database.\\nOnly use the below tools. Only use the information returned by the below tools to construct your final answer.\\nYou MUST double check your query before executing it. If you get an error while executing a query, rewrite the query and try again.\\n\\nDO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database.\\n\\nIf the question does not seem related to the database, just return \\\"I don't know\\\" as the answer.\";\nexport declare const SQL_SUFFIX = \"Begin!\\n\\nQuestion: {input}\\nThought: I should look at the tables in the database to see what I can query.\\n{agent_scratchpad}\";\n"],"mappings":";cAAqBA,UAAAA;AAAAA,cACAC,UAAAA,GADU,gIAAA"}

package/dist/agents/toolkits/sql/prompt.js

@@ -0,0 +1,22 @@
+//#region src/agents/toolkits/sql/prompt.ts
+const SQL_PREFIX = `You are an agent designed to interact with a SQL database.
+Given an input question, create a syntactically correct {dialect} query to run, then look at the results of the query and return the answer.
+Unless the user specifies a specific number of examples they wish to obtain, always limit your query to at most {top_k} results using the LIMIT clause.
+You can order the results by a relevant column to return the most interesting examples in the database.
+Never query for all the columns from a specific table, only ask for a the few relevant columns given the question.
+You have access to tools for interacting with the database.
+Only use the below tools. Only use the information returned by the below tools to construct your final answer.
+You MUST double check your query before executing it. If you get an error while executing a query, rewrite the query and try again.
+
+DO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database.
+
+If the question does not seem related to the database, just return "I don't know" as the answer.`;
+const SQL_SUFFIX = `Begin!
+
+Question: {input}
+Thought: I should look at the tables in the database to see what I can query.
+{agent_scratchpad}`;
+
+//#endregion
+export { SQL_PREFIX, SQL_SUFFIX };
+//# sourceMappingURL=prompt.js.map