@composio/anthropic 0.3.4 → 0.5.0

package/dist/index.cjs

@@ -1,266 +1,253 @@
-"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");
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AnthropicProvider: () => AnthropicProvider
-});
-module.exports = __toCommonJS(index_exports);
-var import_core = require("@composio/core");
-var AnthropicProvider = class extends import_core.BaseNonAgenticProvider {
-  name = "anthropic";
-  chacheTools = false;
-  /**
-   * Creates a new instance of the AnthropicProvider.
-   *
-   * @param {Object} [options] - Configuration options for the provider
-   * @param {boolean} [options.cacheTools=false] - Whether to cache tools using Anthropic's ephemeral cache
-   *
-   * @example
-   * ```typescript
-   * // Initialize with default settings (no caching)
-   * const provider = new AnthropicProvider();
-   *
-   * // Initialize with tool caching enabled
-   * const providerWithCaching = new AnthropicProvider({
-   *   cacheTools: true
-   * });
-   *
-   * // Use with Composio
-   * const composio = new Composio({
-   *   apiKey: 'your-api-key',
-   *   provider: new AnthropicProvider({
-   *     cacheTools: true
-   *   })
-   * });
-   * ```
-   */
-  constructor(options) {
-    super();
-    this.chacheTools = options?.cacheTools ?? false;
-    import_core.logger.debug(`AnthropicProvider initialized [cacheTools: ${this.chacheTools}]`);
-  }
-  /**
-   * Wraps a Composio tool in the Anthropic format.
-   *
-   * This method transforms a Composio tool definition into the format
-   * expected by Anthropic's Claude API for tool use.
-   *
-   * @param tool - The Composio tool to wrap
-   * @returns The wrapped tool in Anthropic format
-   *
-   * @example
-   * ```typescript
-   * // Wrap a single tool for use with Anthropic
-   * const composioTool = {
-   *   slug: 'SEARCH_TOOL',
-   *   description: 'Search for information',
-   *   inputParameters: {
-   *     type: 'object',
-   *     properties: {
-   *       query: { type: 'string' }
-   *     },
-   *     required: ['query']
-   *   }
-   * };
-   *
-   * const anthropicTool = provider.wrapTool(composioTool);
-   * ```
-   */
-  wrapTool(tool) {
-    return {
-      name: tool.slug,
-      description: tool.description || "",
-      input_schema: tool.inputParameters || {
-        type: "object",
-        properties: {},
-        required: []
-      },
-      cache_control: this.chacheTools ? { type: "ephemeral" } : void 0
-    };
-  }
-  /**
-   * Wraps a list of Composio tools in the Anthropic format.
-   *
-   * This method transforms multiple Composio tool definitions into the format
-   * expected by Anthropic's Claude API for tool use.
-   *
-   * @param tools - Array of Composio tools to wrap
-   * @returns Array of wrapped tools in Anthropic format
-   *
-   * @example
-   * ```typescript
-   * // Wrap multiple tools for use with Anthropic
-   * const composioTools = [
-   *   {
-   *     slug: 'SEARCH_TOOL',
-   *     description: 'Search for information',
-   *     inputParameters: {
-   *       type: 'object',
-   *       properties: {
-   *         query: { type: 'string' }
-   *       }
-   *     }
-   *   },
-   *   {
-   *     slug: 'WEATHER_TOOL',
-   *     description: 'Get weather information',
-   *     inputParameters: {
-   *       type: 'object',
-   *       properties: {
-   *         location: { type: 'string' }
-   *       }
-   *     }
-   *   }
-   * ];
-   *
-   * const anthropicTools = provider.wrapTools(composioTools);
-   * ```
-   */
-  wrapTools(tools) {
-    return tools.map((tool) => this.wrapTool(tool));
-  }
-  /**
-   * Executes a tool call from Anthropic's Claude API.
-   *
-   * This method processes a tool call from Anthropic's Claude API,
-   * executes the corresponding Composio tool, and returns the result.
-   *
-   * @param userId - The user ID for authentication and tracking
-   * @param toolUse - The tool use object from Anthropic
-   * @param options - Additional options for tool execution
-   * @param modifiers - Modifiers for tool execution
-   * @returns The result of the tool execution as a JSON string
-   *
-   * @example
-   * ```typescript
-   * // Execute a tool call from Anthropic
-   * const toolUse = {
-   *   type: 'tool_use',
-   *   id: 'tu_abc123',
-   *   name: 'SEARCH_TOOL',
-   *   input: {
-   *     query: 'composio documentation'
-   *   }
-   * };
-   *
-   * const result = await provider.executeToolCall(
-   *   'user123',
-   *   toolUse,
-   *   { connectedAccountId: 'conn_xyz456' }
-   * );
-   * console.log(JSON.parse(result));
-   * ```
-   */
-  async executeToolCall(userId, toolUse, options, modifiers) {
-    const payload = {
-      arguments: toolUse.input,
-      connectedAccountId: options?.connectedAccountId,
-      customAuthParams: options?.customAuthParams,
-      customConnectionData: options?.customConnectionData,
-      userId
-    };
-    const result = await this.executeTool(toolUse.name, payload, modifiers);
-    return JSON.stringify(result.data);
-  }
-  /**
-   * Handles tool calls from Anthropic's message response.
-   *
-   * This method processes tool calls from an Anthropic message response,
-   * extracts the tool use blocks, executes each tool call, and returns the results.
-   *
-   * @param userId - The user ID for authentication and tracking
-   * @param message - The message response from Anthropic
-   * @param options - Additional options for tool execution
-   * @param modifiers - Modifiers for tool execution
-   * @returns Array of tool execution results as JSON strings
-   *
-   * @example
-   * ```typescript
-   * // Handle tool calls from an Anthropic message response
-   * const anthropic = new Anthropic({ apiKey: 'your-anthropic-api-key' });
-   *
-   * const message = await anthropic.messages.create({
-   *   model: 'claude-3-opus-20240229',
-   *   max_tokens: 1024,
-   *   tools: provider.wrapTools(composioTools),
-   *   messages: [
-   *     {
-   *       role: 'user',
-   *       content: 'Search for information about Composio'
-   *     }
-   *   ]
-   * });
-   *
-   * // Process any tool calls in the response
-   * const results = await provider.handleToolCalls(
-   *   'user123',
-   *   message,
-   *   { connectedAccountId: 'conn_xyz456' }
-   * );
-   *
-   * // Use the results to continue the conversation
-   * console.log(results);
-   * ```
-   */
-  async handleToolCalls(userId, message, options, modifiers) {
-    const outputs = [];
-    const toolUseBlocks = [];
-    for (const content of message.content) {
-      if (typeof content === "object" && content !== null && "type" in content && typeof content.type === "string" && content.type.toString() === "tool_use" && "id" in content && "name" in content && "input" in content) {
-        toolUseBlocks.push({
-          type: "tool_use",
-          id: String(content.id),
-          name: String(content.name),
-          input: content.input
-        });
-      }
-    }
-    for (const toolUse of toolUseBlocks) {
-      const toolResult = await this.executeToolCall(userId, toolUse, options, modifiers);
-      outputs.push({
-        type: "tool_result",
-        tool_use_id: toolUse.id,
-        content: toolResult,
-        cache_control: this.chacheTools ? { type: "ephemeral" } : void 0
-      });
-    }
-    return outputs.length > 0 ? [{ role: "user", content: outputs }] : [];
-  }
-  /**
-   * 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: item.url,
-      name: item.name,
-      type: "url"
-    }));
-  }
+//#region src/index.ts
+/**
+* Anthropic Provider
+*
+* This provider provides a set of tools for interacting with Anthropic's API.
+* It implements the non-agentic provider interface for Anthropic's Claude models.
+*
+* @packageDocumentation
+* @module providers/anthropic
+*/
+/**
+* Anthropic Provider implementation for Composio
+*/
+var AnthropicProvider = class extends _composio_core.BaseNonAgenticProvider {
+	name = "anthropic";
+	chacheTools = false;
+	/**
+	* Creates a new instance of the AnthropicProvider.
+	*
+	* @param {Object} [options] - Configuration options for the provider
+	* @param {boolean} [options.cacheTools=false] - Whether to cache tools using Anthropic's ephemeral cache
+	*
+	* @example
+	* ```typescript
+	* // Initialize with default settings (no caching)
+	* const provider = new AnthropicProvider();
+	*
+	* // Initialize with tool caching enabled
+	* const providerWithCaching = new AnthropicProvider({
+	*   cacheTools: true
+	* });
+	*
+	* // Use with Composio
+	* const composio = new Composio({
+	*   apiKey: 'your-api-key',
+	*   provider: new AnthropicProvider({
+	*     cacheTools: true
+	*   })
+	* });
+	* ```
+	*/
+	constructor(options) {
+		super();
+		this.chacheTools = options?.cacheTools ?? false;
+		_composio_core.logger.debug(`AnthropicProvider initialized [cacheTools: ${this.chacheTools}]`);
+	}
+	/**
+	* Wraps a Composio tool in the Anthropic format.
+	*
+	* This method transforms a Composio tool definition into the format
+	* expected by Anthropic's Claude API for tool use.
+	*
+	* @param tool - The Composio tool to wrap
+	* @returns The wrapped tool in Anthropic format
+	*
+	* @example
+	* ```typescript
+	* // Wrap a single tool for use with Anthropic
+	* const composioTool = {
+	*   slug: 'SEARCH_TOOL',
+	*   description: 'Search for information',
+	*   inputParameters: {
+	*     type: 'object',
+	*     properties: {
+	*       query: { type: 'string' }
+	*     },
+	*     required: ['query']
+	*   }
+	* };
+	*
+	* const anthropicTool = provider.wrapTool(composioTool);
+	* ```
+	*/
+	wrapTool(tool) {
+		return {
+			name: tool.slug,
+			description: tool.description || "",
+			input_schema: tool.inputParameters || {
+				type: "object",
+				properties: {},
+				required: []
+			},
+			cache_control: this.chacheTools ? { type: "ephemeral" } : void 0
+		};
+	}
+	/**
+	* Wraps a list of Composio tools in the Anthropic format.
+	*
+	* This method transforms multiple Composio tool definitions into the format
+	* expected by Anthropic's Claude API for tool use.
+	*
+	* @param tools - Array of Composio tools to wrap
+	* @returns Array of wrapped tools in Anthropic format
+	*
+	* @example
+	* ```typescript
+	* // Wrap multiple tools for use with Anthropic
+	* const composioTools = [
+	*   {
+	*     slug: 'SEARCH_TOOL',
+	*     description: 'Search for information',
+	*     inputParameters: {
+	*       type: 'object',
+	*       properties: {
+	*         query: { type: 'string' }
+	*       }
+	*     }
+	*   },
+	*   {
+	*     slug: 'WEATHER_TOOL',
+	*     description: 'Get weather information',
+	*     inputParameters: {
+	*       type: 'object',
+	*       properties: {
+	*         location: { type: 'string' }
+	*       }
+	*     }
+	*   }
+	* ];
+	*
+	* const anthropicTools = provider.wrapTools(composioTools);
+	* ```
+	*/
+	wrapTools(tools) {
+		return tools.map((tool) => this.wrapTool(tool));
+	}
+	/**
+	* Executes a tool call from Anthropic's Claude API.
+	*
+	* This method processes a tool call from Anthropic's Claude API,
+	* executes the corresponding Composio tool, and returns the result.
+	*
+	* @param userId - The user ID for authentication and tracking
+	* @param toolUse - The tool use object from Anthropic
+	* @param options - Additional options for tool execution
+	* @param modifiers - Modifiers for tool execution
+	* @returns The result of the tool execution as a JSON string
+	*
+	* @example
+	* ```typescript
+	* // Execute a tool call from Anthropic
+	* const toolUse = {
+	*   type: 'tool_use',
+	*   id: 'tu_abc123',
+	*   name: 'SEARCH_TOOL',
+	*   input: {
+	*     query: 'composio documentation'
+	*   }
+	* };
+	*
+	* const result = await provider.executeToolCall(
+	*   'user123',
+	*   toolUse,
+	*   { connectedAccountId: 'conn_xyz456' }
+	* );
+	* console.log(JSON.parse(result));
+	* ```
+	*/
+	async executeToolCall(userId, toolUse, options, modifiers) {
+		const payload = {
+			arguments: toolUse.input,
+			connectedAccountId: options?.connectedAccountId,
+			customAuthParams: options?.customAuthParams,
+			customConnectionData: options?.customConnectionData,
+			userId
+		};
+		const result = await this.executeTool(toolUse.name, payload, modifiers);
+		return JSON.stringify(result.data);
+	}
+	/**
+	* Handles tool calls from Anthropic's message response.
+	*
+	* This method processes tool calls from an Anthropic message response,
+	* extracts the tool use blocks, executes each tool call, and returns the results.
+	*
+	* @param userId - The user ID for authentication and tracking
+	* @param message - The message response from Anthropic
+	* @param options - Additional options for tool execution
+	* @param modifiers - Modifiers for tool execution
+	* @returns Array of tool execution results as JSON strings
+	*
+	* @example
+	* ```typescript
+	* // Handle tool calls from an Anthropic message response
+	* const anthropic = new Anthropic({ apiKey: 'your-anthropic-api-key' });
+	*
+	* const message = await anthropic.messages.create({
+	*   model: 'claude-3-opus-20240229',
+	*   max_tokens: 1024,
+	*   tools: provider.wrapTools(composioTools),
+	*   messages: [
+	*     {
+	*       role: 'user',
+	*       content: 'Search for information about Composio'
+	*     }
+	*   ]
+	* });
+	*
+	* // Process any tool calls in the response
+	* const results = await provider.handleToolCalls(
+	*   'user123',
+	*   message,
+	*   { connectedAccountId: 'conn_xyz456' }
+	* );
+	*
+	* // Use the results to continue the conversation
+	* console.log(results);
+	* ```
+	*/
+	async handleToolCalls(userId, message, options, modifiers) {
+		const outputs = [];
+		const toolUseBlocks = [];
+		for (const content of message.content) if (typeof content === "object" && content !== null && "type" in content && typeof content.type === "string" && content.type.toString() === "tool_use" && "id" in content && "name" in content && "input" in content) toolUseBlocks.push({
+			type: "tool_use",
+			id: String(content.id),
+			name: String(content.name),
+			input: content.input
+		});
+		for (const toolUse of toolUseBlocks) {
+			const toolResult = await this.executeToolCall(userId, toolUse, options, modifiers);
+			outputs.push({
+				type: "tool_result",
+				tool_use_id: toolUse.id,
+				content: toolResult,
+				cache_control: this.chacheTools ? { type: "ephemeral" } : void 0
+			});
+		}
+		return outputs.length > 0 ? [{
+			role: "user",
+			content: outputs
+		}] : [];
+	}
+	/**
+	* 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: item.url,
+			name: item.name,
+			type: "url"
+		}));
+	}
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AnthropicProvider
-});
+
+//#endregion
+exports.AnthropicProvider = AnthropicProvider;