@composio/langchain 0.4.0 → 0.5.0

package/dist/index.cjs

@@ -1,211 +1,193 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+let _composio_core = require("@composio/core");
+let _langchain_core_tools = require("@langchain/core/tools");
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  LangchainProvider: () => LangchainProvider
-});
-module.exports = __toCommonJS(index_exports);
-var import_core = require("@composio/core");
-var import_tools = require("@langchain/core/tools");
-var LangchainProvider = class extends import_core.BaseAgenticProvider {
-  name = "langchain";
-  /**
-   * Creates a new instance of the LangchainProvider.
-   *
-   * This provider enables integration with the Langchain framework,
-   * allowing Composio tools to be used with Langchain agents and chains.
-   *
-   * @example
-   * ```typescript
-   * // Initialize the Langchain provider
-   * const provider = new LangchainProvider();
-   *
-   * // Use with Composio
-   * const composio = new Composio({
-   *   apiKey: 'your-api-key',
-   *   provider: new LangchainProvider()
-   * });
-   *
-   * // Use the provider to wrap tools for Langchain
-   * const langchainTools = provider.wrapTools(composioTools, composio.tools.execute);
-   * ```
-   */
-  constructor() {
-    super();
-  }
-  /**
-   * Transform MCP URL response into Anthropic-specific format.
-   * By default, Anthropic uses the standard format (same as default),
-   * but this method is here to show providers can customize if needed.
-   *
-   * @param data - The MCP URL response data
-   * @returns Standard MCP server response format
-   */
-  wrapMcpServerResponse(data) {
-    return data.map((item) => ({
-      url: new URL(item.url),
-      name: item.name
-    }));
-  }
-  /**
-   * Wraps a Composio tool in the Langchain DynamicStructuredTool format.
-   *
-   * This method transforms a Composio tool definition into a Langchain
-   * DynamicStructuredTool that can be used with Langchain agents and chains.
-   *
-   * @param tool - The Composio tool to wrap
-   * @param executeTool - Function to execute the tool
-   * @returns The wrapped tool as a Langchain DynamicStructuredTool
-   *
-   * @example
-   * ```typescript
-   * // Wrap a single tool for use with Langchain
-   * const composioTool = {
-   *   slug: 'SEARCH_TOOL',
-   *   description: 'Search for information',
-   *   toolkit: { name: 'search_toolkit' },
-   *   inputParameters: {
-   *     type: 'object',
-   *     properties: {
-   *       query: { type: 'string' }
-   *     },
-   *     required: ['query']
-   *   }
-   * };
-   *
-   * // Create a Langchain tool using the provider
-   * const langchainTool = provider.wrapTool(
-   *   composioTool,
-   *   composio.tools.execute
-   * );
-   *
-   * // Use with Langchain
-   * import { AgentExecutor, createOpenAIFunctionsAgent } from 'langchain/agents';
-   * import { ChatOpenAI } from '@langchain/openai';
-   *
-   * const model = new ChatOpenAI({ temperature: 0 });
-   * const agent = await createOpenAIFunctionsAgent({
-   *   llm: model,
-   *   tools: [langchainTool]
-   * });
-   *
-   * const executor = new AgentExecutor({
-   *   agent,
-   *   tools: [langchainTool]
-   * });
-   *
-   * const result = await executor.invoke({
-   *   input: "Search for information about Composio"
-   * });
-   * ```
-   */
-  wrapTool(tool, executeTool) {
-    const toolName = tool.slug;
-    const description = tool.description;
-    const appName = tool.toolkit?.name?.toLowerCase();
-    if (!appName) {
-      throw new Error("App name is not defined");
-    }
-    const func = async (...args) => {
-      const result = await executeTool(toolName, args[0]);
-      return JSON.stringify(result);
-    };
-    if (!tool.inputParameters) {
-      throw new Error("Tool input parameters are not defined");
-    }
-    const parameters = (0, import_core.jsonSchemaToZodSchema)(tool.inputParameters);
-    return new import_tools.DynamicStructuredTool({
-      name: toolName,
-      description: description || "",
-      schema: parameters,
-      func
-    });
-  }
-  /**
-   * Wraps a list of Composio tools in the Langchain DynamicStructuredTool format.
-   *
-   * This method transforms multiple Composio tool definitions into Langchain
-   * DynamicStructuredTools that can be used with Langchain agents and chains.
-   *
-   * @param tools - Array of Composio tools to wrap
-   * @param executeTool - Function to execute the tools
-   * @returns Array of wrapped tools as Langchain DynamicStructuredTools
-   *
-   * @example
-   * ```typescript
-   * // Wrap multiple tools for use with Langchain
-   * const composioTools = [
-   *   {
-   *     slug: 'SEARCH_TOOL',
-   *     description: 'Search for information',
-   *     toolkit: { name: 'search_toolkit' },
-   *     inputParameters: {
-   *       type: 'object',
-   *       properties: {
-   *         query: { type: 'string' }
-   *       },
-   *       required: ['query']
-   *     }
-   *   },
-   *   {
-   *     slug: 'WEATHER_TOOL',
-   *     description: 'Get weather information',
-   *     toolkit: { name: 'weather_toolkit' },
-   *     inputParameters: {
-   *       type: 'object',
-   *       properties: {
-   *         location: { type: 'string' }
-   *       },
-   *       required: ['location']
-   *     }
-   *   }
-   * ];
-   *
-   * // Create Langchain tools using the provider
-   * const langchainTools = provider.wrapTools(
-   *   composioTools,
-   *   composio.tools.execute
-   * );
-   *
-   * // Use with Langchain
-   * import { AgentExecutor, createOpenAIFunctionsAgent } from 'langchain/agents';
-   * import { ChatOpenAI } from '@langchain/openai';
-   *
-   * const model = new ChatOpenAI({ temperature: 0 });
-   * const agent = await createOpenAIFunctionsAgent({
-   *   llm: model,
-   *   tools: langchainTools
-   * });
-   *
-   * const executor = new AgentExecutor({
-   *   agent,
-   *   tools: langchainTools
-   * });
-   * ```
-   */
-  wrapTools(tools, executeTool) {
-    return tools.map((tool) => this.wrapTool(tool, executeTool));
-  }
+//#region src/index.ts
+/**
+* Langchain Provider
+*
+* Author: Musthaq Ahamad <musthaq@composio.dev>
+* Reference: https://github.com/ComposioHQ/composio/blob/master/js/src/frameworks/langchain.ts
+*
+* This provider provides a set of tools for interacting with Langchain.
+*
+* @packageDocumentation
+* @module providers/langchain
+*/
+var LangchainProvider = class extends _composio_core.BaseAgenticProvider {
+	name = "langchain";
+	/**
+	* Creates a new instance of the LangchainProvider.
+	*
+	* This provider enables integration with the Langchain framework,
+	* allowing Composio tools to be used with Langchain agents and chains.
+	*
+	* @example
+	* ```typescript
+	* // Initialize the Langchain provider
+	* const provider = new LangchainProvider();
+	*
+	* // Use with Composio
+	* const composio = new Composio({
+	*   apiKey: 'your-api-key',
+	*   provider: new LangchainProvider()
+	* });
+	*
+	* // Use the provider to wrap tools for Langchain
+	* const langchainTools = provider.wrapTools(composioTools, composio.tools.execute);
+	* ```
+	*/
+	constructor() {
+		super();
+	}
+	/**
+	* Transform MCP URL response into Anthropic-specific format.
+	* By default, Anthropic uses the standard format (same as default),
+	* but this method is here to show providers can customize if needed.
+	*
+	* @param data - The MCP URL response data
+	* @returns Standard MCP server response format
+	*/
+	wrapMcpServerResponse(data) {
+		return data.map((item) => ({
+			url: new URL(item.url),
+			name: item.name
+		}));
+	}
+	/**
+	* Wraps a Composio tool in the Langchain DynamicStructuredTool format.
+	*
+	* This method transforms a Composio tool definition into a Langchain
+	* DynamicStructuredTool that can be used with Langchain agents and chains.
+	*
+	* @param tool - The Composio tool to wrap
+	* @param executeTool - Function to execute the tool
+	* @returns The wrapped tool as a Langchain DynamicStructuredTool
+	*
+	* @example
+	* ```typescript
+	* // Wrap a single tool for use with Langchain
+	* const composioTool = {
+	*   slug: 'SEARCH_TOOL',
+	*   description: 'Search for information',
+	*   toolkit: { name: 'search_toolkit' },
+	*   inputParameters: {
+	*     type: 'object',
+	*     properties: {
+	*       query: { type: 'string' }
+	*     },
+	*     required: ['query']
+	*   }
+	* };
+	*
+	* // Create a Langchain tool using the provider
+	* const langchainTool = provider.wrapTool(
+	*   composioTool,
+	*   composio.tools.execute
+	* );
+	*
+	* // Use with Langchain
+	* import { AgentExecutor, createOpenAIFunctionsAgent } from 'langchain/agents';
+	* import { ChatOpenAI } from '@langchain/openai';
+	*
+	* const model = new ChatOpenAI({ temperature: 0 });
+	* const agent = await createOpenAIFunctionsAgent({
+	*   llm: model,
+	*   tools: [langchainTool]
+	* });
+	*
+	* const executor = new AgentExecutor({
+	*   agent,
+	*   tools: [langchainTool]
+	* });
+	*
+	* const result = await executor.invoke({
+	*   input: "Search for information about Composio"
+	* });
+	* ```
+	*/
+	wrapTool(tool, executeTool) {
+		const toolName = tool.slug;
+		const description = tool.description;
+		if (!tool.toolkit?.name?.toLowerCase()) throw new Error("App name is not defined");
+		const func = async (...args) => {
+			const result = await executeTool(toolName, args[0]);
+			return JSON.stringify(result);
+		};
+		if (!tool.inputParameters) throw new Error("Tool input parameters are not defined");
+		const parameters = (0, _composio_core.jsonSchemaToZodSchema)(tool.inputParameters);
+		return new _langchain_core_tools.DynamicStructuredTool({
+			name: toolName,
+			description: description || "",
+			schema: parameters,
+			func
+		});
+	}
+	/**
+	* Wraps a list of Composio tools in the Langchain DynamicStructuredTool format.
+	*
+	* This method transforms multiple Composio tool definitions into Langchain
+	* DynamicStructuredTools that can be used with Langchain agents and chains.
+	*
+	* @param tools - Array of Composio tools to wrap
+	* @param executeTool - Function to execute the tools
+	* @returns Array of wrapped tools as Langchain DynamicStructuredTools
+	*
+	* @example
+	* ```typescript
+	* // Wrap multiple tools for use with Langchain
+	* const composioTools = [
+	*   {
+	*     slug: 'SEARCH_TOOL',
+	*     description: 'Search for information',
+	*     toolkit: { name: 'search_toolkit' },
+	*     inputParameters: {
+	*       type: 'object',
+	*       properties: {
+	*         query: { type: 'string' }
+	*       },
+	*       required: ['query']
+	*     }
+	*   },
+	*   {
+	*     slug: 'WEATHER_TOOL',
+	*     description: 'Get weather information',
+	*     toolkit: { name: 'weather_toolkit' },
+	*     inputParameters: {
+	*       type: 'object',
+	*       properties: {
+	*         location: { type: 'string' }
+	*       },
+	*       required: ['location']
+	*     }
+	*   }
+	* ];
+	*
+	* // Create Langchain tools using the provider
+	* const langchainTools = provider.wrapTools(
+	*   composioTools,
+	*   composio.tools.execute
+	* );
+	*
+	* // Use with Langchain
+	* import { AgentExecutor, createOpenAIFunctionsAgent } from 'langchain/agents';
+	* import { ChatOpenAI } from '@langchain/openai';
+	*
+	* const model = new ChatOpenAI({ temperature: 0 });
+	* const agent = await createOpenAIFunctionsAgent({
+	*   llm: model,
+	*   tools: langchainTools
+	* });
+	*
+	* const executor = new AgentExecutor({
+	*   agent,
+	*   tools: langchainTools
+	* });
+	* ```
+	*/
+	wrapTools(tools, executeTool) {
+		return tools.map((tool) => this.wrapTool(tool, executeTool));
+	}
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  LangchainProvider
-});
+
+//#endregion
+exports.LangchainProvider = LangchainProvider;